# What do we have to attract C++ or other languages' power users to try Julia?

**URL:** <https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491>\
**Category:** Community\
**Tags:** offtopic\
**Created:** [August 9, 2025, 2:39pm UTC](https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491 "2025-08-09T14:39:36Z")\
**Posts on this page:** 12\
**Page:** 2

<div class="post-metadata">

**Author:** ![jling](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/jling/32/212909_2.png) [@jling](https://discourse.julialang.org/u/jling)\
**Post date:** [August 11, 2025, 6:22pm UTC](https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491/22 "2025-08-11T18:22:50Z")

</div>

> [@ForceBru](#):
>
> Yes, Rust has syntax like this:

that’s a bit misleading, in Rust, `x.f(...)` is syntax sugar of `f(x::X, ...)` right? So it’s not that `f` is a “member function of `X`” (as Rust is not big OOP)

---

<div class="post-metadata">

**Author:** ![j\_u](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/j_u/32/219081_2.png) [@j\_u](https://discourse.julialang.org/u/j_u)\
**Post date:** [August 11, 2025, 6:30pm UTC](https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491/23 "2025-08-11T18:30:01Z")

</div>

> [@Hexen](#):
>
> […] As I see it, `Julia` was developed […] as a language for scientific calculations, not as a language for writing programs for scientific calculations.

I’m not a power programmer, albeit it looks like you might be spot on here for now.

---

<div class="post-metadata">

**Author:** ![SergeantMike67](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/sergeantmike67/32/25103_2.png) [@SergeantMike67](https://discourse.julialang.org/u/SergeantMike67)\
**Post date:** [August 11, 2025, 6:30pm UTC](https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491/24 "2025-08-11T18:30:28Z")

</div>

> [@Hexen](#):
>
> Lack of postfix notation as a language base. Often we know what data we want to work with, but we don’t know what function to use to do it. And for ordinary programmers who do not feel piety before mathematical notation it is often more pleasant to call `a.sin().ln()` than `ln(sin(a))`. After typing `.` the autocomplete will obligingly provide all available methods for working with the variable `a`. And it’s easier to read.

I don’t claim to be anything other than at best a guy who know just enough to get himself into trouble but not enough to get himself out. I am ap Ph.D candidate in Evolution and when it became clear that R and myself were going to have a long lasting problems with how things should be done, I began to search for a language that made more sense to somebody who didn’t want to get a degree in CS to write code to do what I want to with the data I collect. I looked at C (and all the odd little character flavor designations like + and then ++ and then @ and do I remember a ! also?) and found the bracketing as an undue demand on my memory to remember to make sure they are all closed and it made reading code like reading, well a CS textbook.

Tried Python and hated two things about it.

1. the whitespace requirements
2. and the postfix notation.

Now it may just be me but ln(sin(a)) makes way more sense as it emulates how you write mathematical formulas on paper, than does a.sin().ln(). The postfix notation is really quite confusing to someone like myself because it looks like you are taking the sine of the natural log of what I’m going to guess is ‘a’. or is it ‘a’ (some mathematical function here) sine of the natural log of something else. How to read a.sin().ln() requires me to make a lot of mental manipulations and assumptions that I’d rather not make. I understand ln(sin(a)) without having to do a lot of thinking about it

Also starting indexing at 1 makes way more sense to this non-CS trained mind. I have a datum (which may be a zero) it is one piece of data and should be “cataloged” as such. So while I get the point of setting your time variable to T(0)=0 in my mind that is actually a piece of data that needs an index which in reality is T(1)=0

These are the 3 main reasons I chose to learn Julia and not the other languages

Just my very undereducated CS mind’s opinion.

---

<div class="post-metadata">

**Author:** ![mbauman](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/mbauman/32/31082_2.png) [@mbauman](https://discourse.julialang.org/u/mbauman)\
**Post date:** [August 11, 2025, 7:43pm UTC](https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491/25 "2025-08-11T19:43:19Z")

</div>

> [@Tarny\_GG\_Channie](#):
>
> I know threads about increasing Julia’s adoption among the general programmer population have been done to death. I’m not making another one of those threads. Instead, this thread would focus on the top 1% of programmers.

@Tarny_GG_Channie, this is precisely one of those threads; you’ve done this many many times. Let’s bring this one to a close soon.

@Hexen and others, we’d love to have your inputs on making Julia — and your use of it, if you’re so inclined — better! But we prefer concrete examples (like that BDD solver case sounds interesting) in more focused and more actionable topics. Please don’t hesitate to open new topics to discuss these more focused cases.

---

<div class="post-metadata">

**Author:** ![Benny](https://avatars.discourse-cdn.com/v4/letter/b/49beb7/32.png) [@Benny](https://discourse.julialang.org/u/Benny)\
**Post date:** [August 11, 2025, 7:44pm UTC](https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491/26 "2025-08-11T19:44:31Z")

</div>

> [@Hexen](#):
>
> And in `C++`, if you use `Eigen`, it [provides](https://eigen.tuxfamily.org/dox-devel/group__CoeffwiseMathFunctions.html) different writing options.

In that case, it’s up to the `Matrix` or `Array` class what its member methods includes. Evidently its member method syntax doesn’t extend to operations on a scalar element.

> [@Hexen](#):
>
> For example, impossibility to store mutable structures/objects in an array by value.

Thanks for clarifying. Indeed, the mutable type concept in Julia (and Python for that matter, given NumPy was brought up earlier) is implemented by pointer indirection, which obviously cannot store contents inline on the stack, in a field, array element, etc. You would have to use immutable types, and changes would be accomplished by reassignment (which can be helped by Accessors.jl macros) or by mutations of other mutable objects assigned to its fields. For example, you’d use `Vector{SVector{3, T}}` instead of `Vector{Vector{T}}` if you wanted a contiguous array of XYZ coordinates, then change a Y coordinate with `@reset vector[index].y = value` (not entirely sure, but I suppose the Rust analog is `Vec<[T; 3]>` instead of `Vec<Vec<T>>`). Avoiding additional heap allocations is typical practice for performant Julia (just as multiply dispatched calls aim for static dispatch, not dynamic), and garbage collection isn’t relevant to how that’s done (since you’re more accustomed to Rust, GC is more what’s necessary when multiple mutable references aren’t curbed yet manual management is absent).

Note that C++, Rust, etc use a different, more classic definition of mutability (and variables) that doesn’t really map to Julia/Python’s. It and other high-level features like pointers and references do give more convenient control over memory at the cost of other conveniences (though what’s considered convenient depends on the language’s philosophy and use case). Still, people must design their structures with care if they want significant inline allocation, and that may not always be feasible or desired.

> [@jling](#):
>
> in Rust, `x.f(...)` is syntax sugar of `f(x::X, ...)` right? So it’s not that `f` is a “member function of `X` ”

Strictly speaking, Rust types aren’t classes, and `rect.area()` is fully equivalent to `Rectangle::area(rect)`. However, types are associated with _inherent_ methods (in the same crate, maybe different modules) that take its instances as the first argument `self`, which serves the same purpose as classic member functions and provides the same benefits. It’s worth highlighting that such methods are not the only or often most of the functionality for a type, just the basics that everyone else can build on. Rust’s _ad hoc_ traits extend functionality with more `self` methods, with the benefits of member method syntax discovery and without the wrapper instances of the adapter pattern. In discussions about the incompatibility of member method discovery with Julia’s multiply dispatched generic functions, it was pointed out that there’s nothing stopping explicit association of basic methods with a type for discovery; don’t need _bona fide_ classes or base Julia to implement that.

---

<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:** [August 11, 2025, 8:29pm UTC](https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491/27 "2025-08-11T20:29:17Z")

</div>

> [@Hexen](#):
>
> (Not relevant, can’t find the article with the additional table where Julia was)[On the Energy Efficiency of Programming Languages](https://arxiv.org/html/2410.05460v1)

There is this article, in Nature Astronomy:

Pierre Augier, Carl Friedrich Bolz-Tereick, Serge Guelton, Ashwin Vishnu Mohanan. Reducing the  
ecological impact of computing through education and Python compilers. Nature Astronomy, 2021, 5  
(4), pp.334-335. 10.1038/s41550-021-01342-y.

But Julia looks pretty good there:

 ![image](https://global.discourse-cdn.com/julialang/original/3X/7/7/77e474a0c7e3dcf3dde7402d9e4ef0d024ec74bb.png)

(disclaimer: that Julia code was optimized in this forum after the authors asked for help. Still, it is just Julia code)

---

<div class="post-metadata">

**Author:** ![giordano](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/giordano/32/2166_2.png) [@giordano](https://discourse.julialang.org/u/giordano)\
**Post date:** [August 11, 2025, 8:40pm UTC](https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491/28 "2025-08-11T20:40:19Z")

</div>

> [@Hexen](#):
>
> (Not relevant, can’t find the article with the additional table where Julia was)[On the Energy Efficiency of Programming Languages](https://arxiv.org/html/2410.05460v1)

Perhaps you referred to

> **[Original work in SLE'17 - Updated Functional results - 2020](https://sites.google.com/view/energy-efficiency-languages/updated-functional-results-2020)**
>
> Updated Compiler / Interpreter Versions (2020)

> [@Hexen](#):
>
> [benchmarksgame](https://benchmarksgame-team.pages.debian.net/benchmarksgame/box-plot-summary-charts.html)

Chapel folks like to plot code size vs performance, to highlight the “high productivity” languages:

> **[Chapel Programming Language (@chapellanguage.bsky.social)](https://web-cdn.bsky.app/profile/chapellanguage.bsky.social/post/3liwvwjsu2s2z)**
>
> The Computer Language Benchmarks Game now has results for Chapel 2.3! These charts show Chapel delivering an attractive mix of performance and clear, concise code when compared to languages like Python, Rust, C and Julia. #HPC
> 
> Browse the CLBG at:...

---

<div class="post-metadata">

**Author:** ![Elrod](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/elrod/32/22461_2.png) [@Elrod](https://discourse.julialang.org/u/Elrod)\
**Post date:** [August 12, 2025, 3:54am UTC](https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491/29 "2025-08-12T03:54:05Z")

</div>

FWIW, C++ is my favorite language.  
It’s great for implementing libraries and building abstractions.  
I wrote a blog post a couple years ago giving an example of how easy it is to write some succinct relatively fast code, giving auto diff (first and second derivatives) of a matrix exponential example:

> **[Competing with C++ with Julia in multithreaded, allocating code](https://spmd.org/posts/multithreadedallocations/)**

The C++ code was shorter and faster than the fastest Julia version. The C++ code had less explicit memory management than the fastest Julia version.

Julia gives a great interactive experience, and Revise is nice for debugging.

I also suspect part of what I like about C++ is that I’ve only used it in personal projects, and never professionally.

---

<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:** [August 12, 2025, 8:16am UTC](https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491/30 "2025-08-12T08:16:06Z")

</div>

> [@Tarny\_GG\_Channie](#):
>
> You need something where it’s pretty much not viable for them to make it work in their languages.

That’s not how programming works. All of these languages (Rust, Julia, C++, …) are Turing-complete, and pretty powerful to boost. Everything is viable in all of them.

But at the same time each offers unique advantages. C++ is great for really large teams, and mature projects with a well-defined algorithm. Rust is great if you want to replace C with a modern language that is obsessed with safety. Julia is great for quick prototyping and refactoring.

> [@Tarny\_GG\_Channie](#):
>
> what Julia has that would attract these power users

Implicit in your post is the misconception that a person is an “X user”. It is true that a lot of people focus on a single language, but this does not mean that they are not aware of other languages. Many Julia users know some C++ or Rust, and similarly a lot of C++ programmers have dipped their toes in Julia.

Julia is what it is — if we can improve it, it should be improved for its own sake, not to “attract power users” from other languages.

---

<div class="post-metadata">

**Author:** ![tamasgal](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/tamasgal/32/27946_2.png) [@tamasgal](https://discourse.julialang.org/u/tamasgal)\
**Post date:** [August 12, 2025, 10:16am UTC](https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491/31 "2025-08-12T10:16:00Z")

</div>

> [@Elrod](#):
>
> FWIW, C++ is my favorite language.  
> It’s great for implementing libraries and building abstractions.  
> I wrote a blog post a couple years ago giving an example of how easy it is to write some succinct relatively fast code

I am with you, albeit I prefer pure C(89 and 99) because code written in that language will probably compile for a very long time, even after humans manage to wipe themselves out 😉

I went through a couple of phases of my three decade old programming experience with hundreds of projects in dozens of languages and ended up with mainly three languages which allow me to achieve everything I want on a computer in the most efficient way on basically three areas:

- **Julia** – for my (astro) particle physics research work
- **C** for everything else
- **JavaScript** when I have to to web stuff

I don’t think C++ or other programmers need to be “attracted” to Julia. To me, the only people who would benefit most (including the whole community and humanity) are scientists who spam and burn hundreds of millions of CPUs/GPUs hours and IOPS on our clusters and grid with crappy Python code.

That’s my two cents…

edit: typos

---

<div class="post-metadata">

**Author:** ![j\_u](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/j_u/32/219081_2.png) [@j\_u](https://discourse.julialang.org/u/j_u)\
**Post date:** [August 12, 2025, 11:58am UTC](https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491/32 "2025-08-12T11:58:52Z")

</div>

I saw that my earlier post was flagged by the Community, and I’m scratching my head a bit as I don’t think it was off-topic, unfocused, inappropriate, or spammy (I even threw in a smile there). I just wanted to say that, although I’ve never met my colleague (I hope he doesn’t mind me saying this) @nsajko in real life, I appreciate his knowledgeable contributions to the Community and his willingness to help others navigate the many intricacies of Julia’s architecture and programming.

---

<div class="post-metadata">

**Author:** ![mbauman](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/mbauman/32/31082_2.png) [@mbauman](https://discourse.julialang.org/u/mbauman)\
**Post date:** [August 12, 2025, 1:00pm UTC](https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491/33 "2025-08-12T13:00:45Z")

</div>

This topic was automatically closed after 17 hours. New replies are no longer allowed.

[Previous page](https://discourse.julialang.org/t/what-do-we-have-to-attract-c-or-other-languages-power-users-to-try-julia/131491.md?page=1)