thetwentyone

Pluto has been quite nice for me to use over the last few years and I even host notebooks using the SliderServer to let others run analysis and examples from the web.

I wish it had my favorite in it so that I could do a blind test to see if it really is my favorite: https://juliamono.netlify.app

I’ve been looking for a way to listen to the audio offline, but this website is very resistant to scraping. I’d appreciate if anyone knew of a free or paid place to download the audio lectures.

FWIW for similar reasons I nuked my Windows install and installed CauchyOS. My main reason for not doing it earlier was concerns about game compatibility but so far the games I want to play either are working without any issue or work after enabling Steam's proton compatibility layer.

One aspect is that Tesla is all cameras, whereas Rivian sees it as important to have multi-sensor suites (cameras, ultrasonic, radar, and in Gen 3: lidar). TBH as a customer I prefer to know that the latter is protecting me instead of just cameras.

Also see the JuliaMono typeface: https://juliamono.netlify.app

It was designed to be a comprehensive monocode typeface to support Julia's full Unicode support.

Anyone have experience with AVP+ALVR vs Valve Index? I have only used the latter but interested if I can use ALVR effectively enough to replace the Index.

Especially because Julia has pretty user friendly and robust GPU capabilities such as JuliaGPU and Reactant[2] among other generic-Julia-code to GPU options.

1: https://enzymead.github.io/Reactant.jl/dev/ 2: https://enzymead.github.io/Reactant.jl/dev/

The author posits that people don't like using LLMs with Rust because LLMs aren't good with Rust. Then people would migrate towards languages that do will with LLMs. However, if that were true, then Julia would be more popular since LLMs do very well with it: https://www.stochasticlifestyle.com/chatgpt-performs-better-...

A crude analogy is the travel of sound waves in air: if you yell at someone, they will hear you long before any single air molecule makes it from here to there.

Isn’t this a very good analogy? What’s so crude about it?

Another tool in this regard is https://github.com/JuliaLang/AllocCheck.jl, "a Julia package that statically checks if a function call may allocate by analyzing the generated LLVM IR of it and its callees using LLVM.jl and GPUCompiler.jl"

I'm currently working on a re-write of a small model from JAX to Julia and finding the Julia code so much easier to write, it's more concise, and find the debugging tools easier to work with in Julia.

I’ve had a good time dabbling with Metal.jl: https://github.com/JuliaGPU/Metal.jl

For Julia users:

https://github.com/JuliaSurv and https://github.com/JuliaStats/Survival.jl

For those interested in this space, a couple of related libraries in Julia:

https://github.com/JuliaComputing/Miletus.jl

https://github.com/JuliaActuary/FinanceModels.jl

I’m the author of the second one, so am always interested to see discussions on financial modeling libraries.

I’m trying to influence this from my small corner of the world here: https://juliaactuary.org/

Come chat in the Julia slack #finance or #actuarial channels!

Odd that the author excluded ForwardDiff.jl and Zygote.jl, both of which get a lot of mileage in the Julia AD world. Nonetheless, awesome tutorial and great to see more Julia content like this!

Much better source: https://avherald.com/h?article=518e5d47&opt=0

The -5 doesn't belong in your ledger, it belongs in the ledger of the person who bought the lemonade. As other commenters have pointed out, the "double entry" refers to multiple entries within your own ledger, it has nothing to do with someone else's ledger.

This has been very helpful to me: https://viralinstruction.com/posts/hardware/#74a3ddb4-8af1-1...

It’s really not specific to Julia, though the language does let you drill down into the details nicely.

Also an interesting Lisp for it’s size is femtolisp from one of the co-creators of Julia:

https://github.com/JeffBezanson/femtolisp

There are different levels of performance to target though - a _basic_ (no SIMD, parallelization, etc) `for` loop can easily be as fast as an C++ version. More performance can be had from both languages, of course. In my experience, the Julia versions offer easier mechanisms to take the code from _basic_ fast to _advanced_ fast. For many, _basic_ fast is fast enough. And when it matters, you can go a bit deeper.

A good example: there was recently a thread on the Julia discourse comparing Julia and Mojo. Julia used no external libraries (compared to 7 with Mojo) implemented a simpler, faster, and cleaner version of the Mojo code that was used to showcase how fast Mojo was: https://discourse.julialang.org/t/julia-mojo-mandelbrot-benc.... Then further still, folks were able to optimize for even more speed with various abstractions that let Julia take more advantage of the hardware.

That's the promise I think Julia makes and delivers on - you can write incredibly "fast" code simply and cleanly. Yes, you can have a higher standard of "fast" which requires a bit more advanced knowledge but I'd argue that Julia still offers the cleanest/simplest way to take advantage of those micro-optimizaitons.

Your comment must be more about the environment of the web browser you are using?

The site is a staticly published version of a Pluto notebook, which uses modern web features to enable interactivity, reactivity, code syntax highlighting, etc. etc. Tradeoffs to enable those features but requires enabling your browser features. The underlying file that the notebook is based on is just a basic `.jl` file, so you could happily run the notebook from a Julia instance instead of the browser-based notebook environment.

Julia itself will be happy to run however you'd like it to of course.

Reference for the "justifiable technical reason"?

Same, though about 3 years here. My company (financial services) officially supports Python and Julia internally.

Currently also predicting more demand than capacity today: https://www.ercot.com/gridmktinfo/dashboards/supplyanddemand

Since it's only implied how it works and there seems to be some confusion in the comments. It seems like the technique is to simply create a very form-fitting insert which won't fit properly if some device is overlaid onto the machine. The insert is not left in the device, but is just used for a quick in-and-out check.

I'm not sure that there's been any "promises" to break. Folks have been saying that it's possible but it'll just take time and effort.

Jumping the gun slightly, but TTFX likely about to get a lot better (5x+ improvement in times) in the next version (1.9). Via cachine of the native compiled code.

https://github.com/JuliaLang/julia/pull/47184#issuecomment-1...

https://juliacomputing.com/case-studies/