shele

> Also, Git's CLI aggressively obscures those core concepts, so any learner is in an uphill battle even if their mind does happen to work the right way

Thank you, that resonates

Ah, that's great, sounds like we are allies, for example when arguing for "let it crash" and other take aways from the Erlang error reporting philosophy in the Julia community.

And thus we who transitioned to Julia from R and know a bit about martingales and less about programming have long been trying to degrade the core of the language and its principles by making `mean` a Base function.

> more than the typical "the code auto-differentiates" or "it's faster" or whatever it is that people have said in the past

Why are you asking to be convinced if you don't want to be convinced?

La mayoría de humans ist gewohnt avoir mehr letters que clés de toute façon.

I would never put in 45s by pressing buttons, it seems we are alike there. But I would put 45 sec in with a (rotary) time control knob though, maybe you want to reevaluate.

That’s an amazingly modern take.

Would it not be better at this point to move on?

The notions first index, current index, previous index, next index and last index and each index are all invariant under shifts of the index set... yet this is the hill people choose to die on.

Some abstractions are costly if the compiler doesn't optimize them away, so one use is to check if that happens. So one iterates changing the Julia code, not the machine code mostly.

A bit earlier even than that.

Right, my point is just: As new methods are added by the owners of new types it requires a common understanding and community consensus how a function should act on new types (i.e. about the "idea" of the function.)

Interesting that is is this way in Haskell in this example: In Julia, there are community/consensus-based processes to what the "idea" of a symbol is (or rather, the idea of a function with its current methods and its future methods defined for new types) and package interoperability often works in a similar way.

Tamas, coming from CL, has donated a very nice list on how "make it easier to help you" on https://discourse.julialang.org/t/please-read-make-it-easier..., so the Julia community has at most streamlined this process a bit :-)

This is a very reasonable article, not cut for front-page drama.

> Imagine spending a lot of time and money picking out the best possible gear for a hobby before actually starting the hobby.

Haha, this is exactly what “hobby” means to a lot of people. Less judgmental: thinking and dreaming about the right tools in disproportion to the need is something people do a lot, presumably because it is a source of joy.

Yes, Julia does support arbitrary indexing because base functions are written in terms of `firstindex`, `eachindex` and `lastindex` etc.

One can see it in the implementation of `filter!` for example https://github.com/JuliaLang/julia/blob/ab4e036b9209967b4273... :

The author is mistaken, there is nothing imprecise or floating about https://github.com/JuliaMath/FixedPointNumbers.jl.

Representing values on a scale from 0.0 to 1.0 instead of 0 to 255 (say) is a good idea if you have to do things like DFT. Most software implementations use fixed point arithmetic for that.

The Julia-code has some performance flaws in the hot loop (like making a superfluous copy of a matrix before just reading it.)

Yes, but that’s a different discussion.

I think this is about subvocal but conscious thoughts.

“He can easily while away an hour without having a single thought.” No! It is “not a single _verbalized_ thought”! To write such an article one should have some understanding that thoughts exists outside mental verbalization

I remember that this is not the whole story, the Spanish invasion and then European invasion was on the larger scale moving slower than the diseases.

There is this S-curve of the amount of newly starting S-curves where we are going to see a slowdown...

Talking about measuring time I would put a date on the blog post

You certainly can build more than you can reasonably maintain, but as in cities live humans workforce and ability to maintain follows. So something else must be the concern: inefficient patterns (urban sprawl) or imbalances in the wealth and liability distributions. The latter can be fixed at any moment in a functional society but can’t be fixed easily in a flawed democracy with powers hugely profiting from the imbalance

So I see the concern

Yes, that restart is painful exactly because it interrupts the "built your program in memory while you’re writing the source code file" OP talks about.

Julia is much closer to Clojure than to Python in this regard, which brings back the point from above that homoiconity isn't the key ingredient

Just keep it running as a daemon? https://github.com/dmolina/DaemonMode.jl

Lol, this is so nice. It is literally what OP asked for: " modulo to remain within some range" is just mod(myvalue, myrange)