Savy!
Definitely try 1.10, this is the Julia version that finally made Makie usable for me.
julia> @time using GLMakie; plot(rand(10))
2.916235 seconds (4.18 M allocations: 447.190 MiB, 10.54% gc time, 1.28% compilation time: 53% of which was recompilation)
10 Likes
You werenāt annoying [This was supposed to be a private message, anyway actually ok, and maybe good it wasnāt.] and it seems awesome what youāre doing already. And Manim, I didnāt know of, only 3Blue1Brown, who apparently made it, not only his animations with, so I learned something from you and others about e.g. it. FYI: Heās now in the Julia community, or at least teaching Julia. As I stated, itās not either or, use Python with and e.g. Manim.
Thatās not something Iāve seen happen, or I donāt see those .pyc files so Iām not sure happens for all code, or just packages(?). Anyway doesnāt happen for Julia code, only packages are precompiled, and I would like that changedā¦
1 Like
It used to show up in the same directory but they reasonably changed it to a separate cache.
Not sure how far that can go. Executables are a bit more flexible, you could compile something as isolated as a function specialization. But for loading code into a session or composing with other code somehow, you need a module. Youād also want the cache to update upon source and environment changes, and at that point you have a package. .pyc files update as well, but I think (not sure) that they donāt need to update when imported dependencies do because the bytecode doesnāt assume anything about the dependencies to make optimizations.
From the perspective of a guy who first programmed on punch cards and had to wait overnight for my deck to run on the mainframe (all the time walking barefoot to school in the snow uphill both ways), thereās a tradeoff view of the latency.
Think of it as a the difference between watching an hour of a streaming series versus spending the same hour watching Tik-Tok. Different, right? Tik-Tok gives quick bursts and leads to a quick trigger finger for scrolling to the next. The reason is the dopamine rush of seeing what happens next. After tearing lose, thereās very little that can be recalledāit was all a rush. The series, on the other hand, is setting context constantly to enable understanding of the characters, the environment that they are struggling, in one way or another, to overcome, and the directions in which the navigation of the environment and the development of the charactersā inner lives and outer circumstances tend. Although an episode may end with a cliff hanger until next week, the anticipation experienced comes with built-in deferred gratification. That process isnāt driven by just the novelty anticipation circuits involved in stirring up the dopamine. Although the emotional circuits may be humming in the background, there is also some prefrontal cortex cognitive involvement as well. The simmering of the mixed ingredient serves up a rich stew to be savored.
My early experience didnāt lead on to a career in software development, but it shaped my later language learning and what Iāve discovered in moving between compiled and interpreted languages is that the difference is similar. Specifically, in debugging, I react to errors differently. In interpreted languages, Iāll try something, it throws an exception and Iāll search first for a stupid typo and if thatās not it the fallback amounts to āwell, maybe this will work.ā In compiled languages, Iām damned well not going to fall for stupid typos because of the time penalty and when I do get a more substantial error, I make sure that I understand exactly what the error means before I try fixing it with shots in the dark. Thatās my human nature.
One thing that helps to offset the time-to-first-compile cost for me is to start a session in a project with a warmup script that runs what amounts to a series of hello-worlds for the functions that Iāve got developed to date for it. That way, new stuff in the session only needs to be compiled.
6 Likes
Now imagine if we took that warmup script and cached all the compilation the occurred while doing so. That is the system image and that is what PackageCompiler.jl will help you build:
1 Like
Good to know. Iām going to try adding a provisional compiled version like this to projects. Great measure twice cut once advice.
Now I donāt even know what to say to that 
. But well, again, you guys areā¦ right! I was a little stupid (a lot ig). Ooooo andā¦ wouldāve been quite something in the early days of programming eh?
I see weāve come a long way, I only meant to convey my feelings about how Julia compares to other languages. Although now Iāve come to an understanding that each of them has their own purpose, and while Julia is a slight bit behind in TTFC itās not that much of a deal breaker, given the computational speed. Also, things are always improving and there are ways to speed things up!
1 Like
Soo THAT is what it does!
Ahhh! Now I get it! Thank you!
Just trying to pass on hard lessons, the way old guys like to do. Youāll be doing the same no doubt. 
1 Like
Wait, you can compile plain old Julia code too?
What is the purpose of Modules then (apart from being able to mention what you want to export and have the naming right)? I never really understood that.
You gotta first define all your functions and stuff. Add the Module and export statements. Then include the file, which you can do with others too and finally call it as a module as well?
How do you use modules if it isnāt for being able to compile them? (In the documentation you provided, they compiled a simple julia code, not a module.)
(sorry this is wondering a bit off topic)
+1 on gamedev ā I think Julia would be great for games! Iāve used it for simulations for tabletop role playing systems and it was a lot of fun for that.
2 Likes