snicker7

I don't think you need to rebuild the compiler. Here is a proposal how how this can be done using the work to compile Julia for GPU's:

https://docs.google.com/document/d/1rLpZf-HK6b9uYPDT_piUza4L...

Referring to start-up latency, the author asserts:

> But the problem is fundamentally unsolvable, because it's built into Julia on a basic design level.

Citation need. Today, the Julia compiler runs in JIT mode. But there is nothing preventing it from being ahead-of-time compiled (indeed, some work is going behind the scenes to make this happen). There is also an interpreter for Julia. I don't see latency or large memory footprints as being "fundamentally unsolvable".

I speculate that the reason why Amazon charges so much for egress (other than to nickel-and-dime its customers) is that it inhibits hybrid-cloud or multi-cloud architectures. It promotes lock-in.

In literally every business domain, Amazon succeeds not because of "customer obsession", but because of their willingness to engage in anti-competitive or outright monopolistic practices.

"But if you need a begin/end block for the above style; you might as well write in the vanilla style."

I disagree. I use assignments for multi-line functions. It makes the code more aesthetically consistent. It also saves a couple of characters.

The position of a cleric is different than, say, a celebrity or a professor. Adherence to religious dogma (in both thoughts and actions) is a strict requirement.

The "idiomatic" way to access the first element in an array/sequence in julia is to use the `first` function, e.g. `first(arr)` vs. `arr[1]`. This works across a larger number of array types, including OffsetArrays with 0-based index offsets.

Proprietary languages work when they fill a niche. I work with the Q/K programming language. It's closed source and, from what I understand, has a significant licensing fee. But it is a language designed specifically to power trading systems (via the KDB+ platform/ecosystem). It fills a niche well, and is popular in the industry.

I think the arguments on both sides are valid.

In dynamic programming languages, I generally prefer factoring business logic outside of procedures and into lookup tables. This is sometimes called "data-driven" or "table-oriented" programming. It eliminates control flow, which makes code more maintainable and less buggy.

Using Julia's dispatch mechanism accomplishes a similar goal. Here, multiple dispatch is akin to a table lookup. It may even be faster than the explicitley data-driven approach since the lookup can be done in compile-time.

I just finished going through the SICP text (and most of the vid lectures). Upon reading it, I realized how much I and millions of others got robbed of a proper software engineering education.

Julia is basically a trojan horse for Lisp. Syntactically, it looks kind-of like Matlab. But semantically it is very much in the Lisp family. Since 1959, Lisp remains the best idea in computer programming. And Julia is bringing it to the masses.

I met one of Vladimir Arnold's grandchildren at a high school math summer camp. One of the things that stood out to me was his insistence that his proofs were as simple and understandable as possible. Unlike other students, he would intentionally avoid using sophisticated techniques. He would brag that a "third grader" could understand it. His preference for simplicity and elegance was clearly inherited from his grandfather.

Lots of finance companies shell out a lot of money for KDB+, a fast real-time database. Other than performance, the main selling point is that it comes with its own imperative language (K/Q). You can build entire API's and trading systems in Q: persistence, load balancing, streaming analytics, &tc. In that way, Q solves a different "two-language problem". There are not many serious competitors.

If Julia had its own lean realtime database implementation, then I can see it becomming a killer language for finance. JuliaDB/OnlineStats is probably 60% of the way there.

I think what you are describing is a perfect advert for declarative/immutable infrastructure. Yes, it may require work and talent. But that's the price to pay for resiliency. Invest and modernize your tech stack or go bankrupt. Cloud tech can help. As can Guix/Nix.

For satellite seperation dynamics modeling, NASA switched from MATLAB (Simulink) to Julia and got a 15,000x performance boost.

https://www.youtube.com/watch?v=tQpqsmwlfY0

What warts did you encounter? What language features / tooling would make Julia easier to productionize?

Why NY of all states?

As another commenter pointed out, DataFrames.jl is already faster than data.table in some benchmarks.

And that's the killer feature of Julia. It is easier to micro-optimize Julia code than any other language, static or dynamic. Meaning if Julia is not best-in-class in a certain algorithm, it will soon.

That's because Microaoft doesn't dare use this for production code (presumably).

They are 100% okay with letting their competitors get into legal hot water.

One issue I have with query languages is how poorly they interact with the "host language" . SQL requires non-composable string templating or complex, low-performance ORM's.

The only query languages that do this "right" are datalog (Datomic) and Q/K (KDB+, Shakti).

Will wearing brown face be classified as hate speech? Or does the bill have a carve-out for LPC politicians?

I love to how you refer to electrical and mechanical engineering as "legacy".

"... the drama school plans to eliminate tuition for returning and future students, removing a barrier to entry for low-income students ..."

No better way to end the cycle of poverty than ... a theater degree.

This "curated" list has hundreds of volumes. I wonder what an uncurated list would look like.

In practice, the typical software developer is not terribly well-read. The number of (non-mandatory) volumes most devs read (not just use as bookshelf decoration) is probably in the lower single digits. If you read one software engineering book a year, you are probably in the top 5%.

"If Montenegro is not able to repay China's state-owned Export-Import Bank on time, the bank then has the right to seize land inside Montenegro"

China's about to sprout the first of its European colonies.

I used to work at a financial data provider. Our clients were institutional investors (e.g. banks, mutual funds). We would FTP our data directly to our client's machine (or SFTP for our more savvy clients).

We also lost Bell labs.

It means that "Apple Music" cannot rely on an "online platform" (large online service) owned by Apple.

A more practical example is that Google can't run its ad-tech services in GCP. And Amazon cannot run its online store in AWS. They could, however, use each other's cloud. But not their own.

I clicked the link expecting some sort of open source library. Instead, the "repo" contained just proprietary binaries. Not even docs.

"Publishing to GitHub" used to be synonymous with donating open source code, with all the goodwill and recognition that entails. Publishing proprietary binaries on GH effectively steals attention in a space that used to be reserved for FOSS projects.

No data export feature is pretty damning. Many organizations, especially government, have strict record-keeping requirements (e.g. for US federal agencies/departments, it's required by law). Data export isn't nice-to-have, it's critical functionality.

> Note that those issues are about deterministic performance, not results.

Not at all. The issue is that the default sysimage distributed with Julia cannot be reproduced across machines, e.g. there is no proof that it hasn't been tampered with. This is an open issue in Guix and Nix, though it affects all platforms.

> One of the places Julia really excels with reproducibility is inter OS

There really is no such thing as reproducibility in Windows, at least not in the sense outlined in bootstrappable.org . If you care about reproducibility, you've chosen the wrong platform.