mkborregaard

Miles Guo is also part of Trump's Mar-el-Lago resort

Even though you can do `@which naked_function` it's a fair position to have that you prefer to import modules and be explicit about where they come from. I tend to prefer explicitness like that in package code, but for data analytical scripts (like the examples here) it would be superfluous in my opinion.

It is nice that Julia leaves this style decision to the user. I personally find the constant prepending of modules to be one of the clumsiest aspects of Python for data analysis.

It's funny because it is true

Program structure by text formatting is a misfeature, though. What you do need though to make sure code remains readable is strong convention. I think actually that's the most unique feature of Julia (as also alluded to in the post) - how much of julia's ecosystem that works because of social convention (and conversation).

Learning a lot from this thread, seems really usfeul

Another compelling argument is that {} , while very easy to type on an English keyboard, is highly awkward on keyboards of almost any other language in the world. E.g. I'm Danish and on my Mac { involves flexing the right thumb down to hit right-alt while typing 7 with my middle finger and holding down shift with my left pinky. `end`, though, being actual letters, is completely easy and fast to type (on languages that uses the latin alphabet).

That is in fact how an argument becomes an argument from authority. Also, it has become an HN meme to post the Dijkstra comment every single time there's a post mentioning Julia. It's not like it's news to anyone.

In fact, almost every solid julia package uses arbitrary indexing for input arrays. `for i = 1:length(x)` is discouraged in production code, instead the ideom is `for i in eachindex(x)`.

Some algorithms work better with 0-based indexing. But maybe, just maybe, there are other aspects to look at when evaluating a programming language than "it doesn't by default follow my favourite indexing type". Especially given that 0-based indexing is very easy to use for any array you may wish to use it for.

An important thing that many people fail to realise is that Julia-1.0 came as a surprise to package authors as well, and thus the first month of the the release has been a scramble to get everything working on 1.0. Unfortunately the pre-1.0 package manager did not have good facilities for upper bounding versions - so essentially everybody's packages would install on 1.0 but be broken.

At exactly the same time, a lot of people thought "hey, 1.0 time to check out this new language", and would experience all those crashes.

Doing a review of Julia based on the experience in the first month after 1.0 will be grossly misleading. I've used the language progressively more for the last 3 years, and also teach a university R course, so I have some experience to base that claim on.

To be exact, the only thing sold there is hash, though the article insists on using the blanket term "drugs". The reason it's sold there is that the commune has decided that it's unfair to label hash as a drug (unless nicotine or alcohol are also labelled as drugs, which they are in a sense of course). Christiania is the most drug-free area in all of Copenhagen.

The blog posts highlights this as something planned. It does sort of work already, but not completely.

Just a response for a few comments, since you talk with confidence but could maybe do with a closer look: 1. You end with `end` in julia. 2. You can use indexing with any base, not just 1 - no performance penalty. 3. The julia repl comes with latex completions making it very easy to just type e.g. \sigma and get the sigma sign. 4. The package system is moving both directions - functionality is split into modules for interoperability, but are gathered in batteries-included metapackages again. Like typing `using DifferentialEquations` will load all 60 small DifferentialEquations packages (centrally documented), but you can easily plugin alternatives if you like.

The `length(linearindices)` and no `size` etc are for a short transitory period while packages are ported to the indexing-based-non-reliant framework.

One of the most mindboggling thing about the recurrent 0- vs 1-based indexing discussion is how incredibly rarely that difference is ever used programmatically in Julia. Most of the large julia packages are programmed in a way that doesn't care whether the array is 0 or 1 based. It is important in some other languages, and then I just think people are happy that this is something that everybody can agree to disagree on. I don't think the discussion is very productive though.

What makes you say it lacks critical mass? I don't think that's accurate, but of course it takes time. Implementation time is important, yes - but julia is not just a fast-to-run-language, which is essentially the point - it is a fast-to-implement language.

Julia supports indexing with arbitrary bases, and it generally works ecosystem-wide.