snicker7

TeXmacs is great (probably best-in-class). However, my biggest gripes with it is how non-portable the TM files are. The only tool that works with these files is texmacs itself. In particular, you can't even convert these files without the full texmacs GUI/runtime. Pity, since I would love to use it as a markup language.

Like Svelte, Clojurescript can "compile" to reactive code (one advantage of being lispy) via Mr. Clean [1]. No VDOM, no library overhead.

[1] https://bitbucket.org/sonwh98/mr-clean

Guix/Nix does this better across many programming languages. Unlike language-specific package managers, Guix is fully recursively reproducible ("bootstrappable"). And Nix isn't terribly far behind, either.

Julia itself is not even reproducible: https://github.com/JuliaLang/julia/issues/25900 https://github.com/JuliaLang/julia/issues/34753

Great. Abolish all debt (student loan debt, mortgages, credit cards, business loans, bonds). Make it proactive too. Have the government automatically pay off everyone's credit cards every month. Infinite wealth for everyone. True justice and equity.

tl;dr

> Almost all of the company consisted of very junior people, often with no experience outside of that company.

Lesson to learn: there is a reason why experienced coders cost more.

This is tangential, but the author is an incredible technical writer: https://scattered-thoughts.net/

Not quite. PackageCompiler isn't automagic. The sysimage doesn't get automatically updated in the REPL. You have to create one manually (and this requires tracing instead of static type inference which Julia can do). So the workflow isn't zero-friction. And StaticCompiler hasn't been updated in over a year.

The problem with Julia tooling in general is that they feel 90% done. And tooling is, in my opinion, more important than the language itself.

It would be nice if their was an "offline version" of this, e.g. automagically cache all compiled code to disk. Daemon mode isn't restart-friendly.

How about investing in a split keyboard? Uaing one promotes good posture if both halves are kept at shoulder-width.

> She never lost interest in it, using it for the rest of her life.

Oh no! Did she pass away?

Reliance of keyboard chording is seriously un-ergonomic. But Emacs provides a number of escape hatches (evil, kakoune.el, god-mode), much more than almost any other computer program.

The political narrative they are trying to push is to "abolish the app store".

oneApi.jl has a Julia to SPIR-V (Vulkan) compiler.

AKA Julia does GPU better than CPU.

Nothing afaict. But only a small number of packages are supported.

I use it as a package manager on another distro (in my case, popos; that's how a lot of people use it afaik). Considering using it as a VM. It works quite well as a supplementary package manager, but has glaring deficiencies with some languages / build systems (gradle, npm, Julia, etc.)

What an incredibly concise, elegant implementation.

Julia defines ≠ in Base.

julia> 3 ≠ 4

true

Some things the author could have included:

- const is not the same as immutability, you could have a const variable pointing to a non-const data structure.

- Type-stability can be checked using the '@code_warntype' macro.

- While Julia's built-in arrays are columnar, user defined array types (for which there are dozens in the wild) can be formatted in any way.

Too complicated. I need a framework for Unicorn.

Antisemitism is now a "progressive" stance.

And they, you know, couldn't demand rights to the code of their own OS? Sounds like Sun had some galaxy-brainers of their own.

Not fully owning your own drivers/OS is something only a galaxy-brained MBA could think of.

This has been my experience, too. Granted, I have used guix longer than Nix.

Another advantage of Guix is just how readable package definitions are. Nix packages often contain embedded shell code + a "functional" DSL. Guix packages are written in a much more declarative style. It kind-of looks like executable JSON (I guess that's the point of lisp, right?).

This looks really cool! Some Q's:

- How do you do back-testing when strats are E2E-encrypted? Client-side computation? Homomorphic encryption?

- How do this DAGs map to computations? Compile to custom VM bytecode?

Teachers get a lot of (empty) praise in the US. But many of them allow bullying. Many ARE the bullies. I've known a teacher who sold drugs to students. I remember a classmate who was r*ped by a teacher.

+1 for John Baez, one of my favorite math writer. Especially the Azimuth blog: https://johncarlosbaez.wordpress.com/

Nothing new or surprising. Anyone who regularly uses both systems knows about the Windows performance tax.

Most notable is the performance improvement of the recent Windows update. I wonder what happened.

Your concerns are absolutely valid. Julia tooling is lacking, and tooling quality can be more important than language quality. There is a reason why Java is so popular.

I feel that most of your points can be addressed if the compiler's "abstract interpreter" (static analysis) procedures were exposed and reliable/stable. Some packages (e.g. Mjolnir.jl [0]) attempt to re-implement it. Others (e.g. JET.jl [1]) try to hook into Julia's undocumented/private compiler internals (CoreCompiler). Rightfully so, only the most intrepid are willing to do this.

[0]: https://juliapackages.com/p/mjolnir

[1]: https://juliapackages.com/p/JET

JuliaCon 2020 talk: https://www.youtube.com/watch?v=GczF2zmJKlk