It's rather unclear how to respond to this. Suppose I find (which I do) that:

* Julia is a joy to use and fits my use case and/or personal development style really well;

* Other tools have not been such a natural match to my needs;

* Julia has its fair share of limitations, and someone else with different priorities would quite reasonably not find it an appropriate tool;

* Julia is not widely known, and other people may benefit from discovering something about Julia, just as I did.

How should I share my enthusiasm (and, with luck, bring Julia to someone who would enjoy it) without promulgating preachy blindsighted hype? Do I have to wait for a big language release?

The parent comment hints at a knife's edge that must be walked when telling people about Julia. Anything like "I use Julia for X" or "in Julia you can do Y this way" is--understandably!--met with "okay, but why Julia at all; why not a more mainstream tool like Python?" But if you elaborate with "I use Julia for X because I find that in this case Julia > Python for reason Z," you risk being labeled an anti-Python zealot.

So, serious question to the parent comment author or others who feel similarly: what are some ways in which you would find it non-offputting for the Julia community to share its enthusiasm or experience with a broader audience?

Well, as someone that has been lightly interested in Julia lately this sort of content is something I am interested in. It feels like there are many of us.

My own impression of the Julia community has been rather pleasant. I think they are actually almost too humble and comfortable with their niche. Rust is... the polar opposite?

YMMV.

There's no coordinated effort to do this.

These are all independent pieces that were written at different times by different people.

Where do you see the arrogance in the OP? It's showing exactly what's being claimed

"Why does Julia work so well", "The unreasonable effectiveness of Julia" tbh read as pure fanboyism at best, but more realistically as an effort to drum up a language that could need some attention, or getting "web mentions" for some hidden investment agenda.

"The Unreasonable Effectiveness of X" is a reference to the well-known 'the unreasonable effectiveness of mathematics in the natural sciences'. It's turned into some sort of meme. Maybe you've seen 'the unreasonable effectiveness of recurrent neural networks' before.

What you were referring to is a talk by a core developer at JuliaCon 2019 titled 'The unreasonable effectiveness of multiple dispatch' [1], which has less of a fanboy-vibe imho.

Edit: Oh. I didn't notice the arstechnica article had this exact title. That's a bit cheap...

[1] https://www.youtube.com/watch?v=kc9HwsxE1OY

I suspect that the title of the Ars Technica article was a reference to the talk title, which was a reference to many other pieces with similar titles, which are all ultimately references to the original one.

As someone who’s actually used the language (sigh) the “hype” around Julia is more excitement about a modern language that’s hitting a broad sweet spot in a unique way.

Julia is a delightful combination of ease of use, clarity, and performance. It lets one concentrate much more on the problem at hand than language related boilerplate (I’m looking at you, Rust).

I’m hopeful that Julia will become one of the most used general purpose programming languages in the long run. It’s certainly got what it takes!

This was part of a tutorial series for a data science program

The "unreasonable effectiveness" article wasn't, to my knowledge, by a community member. It's normal for magazines to have enthusiastic headlines.

You're making a lot of assumptions here that aren't very kind or well supported.

But the article is literally about why it optimizes as well as it does, and what are the engineering trade-offs. In the first section:

>But what we will see in this example is that Julia does not always act like other scripting languages. There are some "lunches lost" that we will have to understand. Understanding how this design decision effects the way you must code is crucial to producing efficient Julia code.

This is more about how the compilation process is working to both help people understand how to write optimal code and to understand what optimizing compilers need in order to work. The engineering trade-offs, like slow performance of globals, errors in functions that would change types, etc. are all demonstrated. If you read a full description of the engineering trade-offs and think that it's a marketing tool, then you must think it made the right trade-offs? I don't understand why that would be bad.

I was making a general comment about the community. I don't have a problem specifically with the original post (which is several years old now).

A "general comment" that is name calling without specifics, suggestions, or examples isn't very constructive.

We've had the exact same thing in the past with other hot new languages and frameworks. I guess lots of people are discovering Julia now, and that's also relevant to HN.

You could post a list of topics that are frequently posted on HN and mark each topic as positively commented on or negatively commented on. Maybe add a trending graph over time too.

Edit: I’m not being snarky. Such a list or view could be useful to get the pulse of the times on HN.

I’ve thought for a while that it would be fun to research which users post the most with respect to which subject. I think if you had a time series of HN hot topics and a graph of evangelists, then maybe some interesting patterns would appear. Covariance between posters would be especially interesting to me.

I think you are confusing hype and buzz. Those are different things.

I agree, and I think it's worse than Rust because Rust at least mostly lives up to the hype, and the main caveats (compile time, borrow checker complexity, etc.) are well known at this point.

How many people know that loading the graph plotting library takes 30 seconds, and that is working as intended?

https://github.com/GiovineItalia/Gadfly.jl/issues/251

I've tried to use Julia a number of times and the experience is always worse than Matlab.

"the", graph plotting library? There are several and gadfly isn't the most popular.

Compile times have dropped precipitously, around 5 sec on master for plots.jl. less than one second if you use the package compiler.

This doesn't purport to be a review of Julia, it's one small part of a tutorial series so not sure why you are expecting a discussion of every trade-off.

Also, what part of Julia is being oversold here?

> and that is working as intended?

I cannot reconcile your claim with those quotations from the GitHub issue:

> It's frustrating, but I don't think it's a permanent situation. A lot of work has already been done on pre-compling Julia code, and when that's extended to packages, things should be much better.

> Making this stuff more convenient is definitely desirable and will happen.

> Agreed. But do keep in mind that the procedure I outlined allows you to avoid precisely this problem, with very little effort

> That would be nice. It will happen when someone makes it happen.

The issue is from 2014...

For "recent" development, there's a lot of work going into fixing latency issues and improving load times of packages generally: https://github.com/JuliaLang/julia/pulls?q=is%3Apr+label%3Al...

It's totally fair and honest to take an issue from 2014(!) and go ''well this is why X sucks''.

According to githut, usage is declining. I wouldn’t read too much into it, but it is one empirical measure.

https://madnight.github.io/githut/#/pull_requests/2020/3

I assume the marketing is to try and revitalize things. I’m not clear on what The Julia developers’ profit model is, but I would assume they have incentives to promote public interest.

Download metrics show usage doubling every year.

As I said above, There's no coordinated effort to do this.

These are all independent pieces that were written at different times by different people.

That only indicates downloads, though. One user might download many times for various reasons (containers come to mind). Does the Julia compiler have telemetry like .NET core that monitors it’s users?

I would also be quite shocked if whoever spent $5M in seed capital for JC would not expect or demand some amount of digital marketing.

What a weird metric to use. Its not growing as fast as Python and Javascript, so the stats go down, so the conclusion is its usage is declining? I dont think it works that way.

The source data shows decline in absolute numbers for pushes. 1432 last quarter, 19073 at peak Q3 2015. It seems to flatten out in 2018 and stays in the 1500-3000 range.

Most of the work moved the package ecosystem as the standard library shrank with many of the things in there moving to separate packages (for example, even the package manager is a separate package: https://github.com/JuliaLang/Pkg.jl). The result of this is that what you now see in Julialang/julia is mostly compiler work (and some tweaks to Base things like linear algebra overloads). With that said, it's quite an actively developed compiler!

JuliaCon 2019: 500 attendees JuliaCon 2020: 20,000 attendees

Doesn't seem to be declining.

Was JuliaCon 2020 remote? That probably has more to do with it. I can’t possibly imagine there are 40X more active users in one year. The niche it serves isn’t particularly large, either.

Yes, it was completely online. The comparison doesn't make sense.

Also, next time it's IRL the numbers would seem to indicate a huge setback, so I wouldn't use those :D