I believe BuildKit solves the dependency graph problem. Docker has shipped with it since 18.09. It is opt-in for now so you have to use e.g. `DOCKER_BUILDKIT=1 docker build ...`.

https://github.com/moby/buildkit

I had looked into this a while ago, and I forget why, but I thought it was a mismatch; however, looking again at the list of downstream projects, this one at least seems compelling for the use case I described:

https://docs.earthly.dev/examples/monorepo

At least it addresses building the right Docker image--it doesn't seem to address building the broader Kubernetes manifests, but I'll take what I can get at this point.

This primary source provides better details on YouTube's policy: https://support.google.com/youtube/answer/9891785?hl=en. It includes concrete examples of content that is banned under this policy.

These seem totally reasonable given the circumstances. I wish people would read these specific examples instead of jumping immediately to accusations of widespread censorship and accusing Youtube of being arbiters of disputed science.

>Content that disputes the efficacy of local health authorities’ or WHO's guidance on physical distancing or self-isolation measures to reduce transmission of COVID-19

How about this? Can reasonable people disagree about distancing and isolation measures?

Can you elaborate on your experience?

I have great respect for Rich Hickey and I recently saw a cool talk about a financial startup using Clojure in production [1]. I have kept track of the language for some time but have never had the chance to use it in any serious capacity.

[1] https://www.youtube.com/watch?v=fnediEWRuyI

I think it’s a great language and a good community but I think some of the opposition to static types from Rich Hickey at the top is silly and I also find it genuinely harder to use languages which aren’t gaining wider traction after being around for over ten years.

I like to watch talks by programming language designers. Some that readily come to mind are Rich Hickey, Joe Armstrong (RIP), and Stefan Karpinski.

Some of my favorites are:

- Simple Made Easy (Hickey): https://www.youtube.com/watch?v=oytL881p-nQ

- The Mess We're In (Armstrong): https://www.youtube.com/watch?v=lKXe3HUG2l4

- The Unreasonable Effectiveness of Multiple Dispatch (Karpinski): https://www.youtube.com/watch?v=kc9HwsxE1OY

They do not just show ads. They also display content.

Existing in a filter bubble has a strong effect on your perception. Perception has a direct influence on your actions. Couple this with interfaces which are purposefully addicting ("high user engagement" is a euphemism), and you can very directly influence behavior.

The pervasiveness of smartphones means that these apps are only a few clicks away for virtually the entire world population. And worse, once these apps are installed on your phone, they relentlessly pull you back in with and endless stream of notifications.

It is not only Facebook. Applications like Reddit, YouTube, Instagram, Twitter, and TikTok all follow the same basic patterns.

It is not an overly dramatic description. If anything the public has been frightfully unaware of the influence that these companies can exert on the world. I am glad that this film has brought these issues into the spotlight.

There was a huge discussion shortly after Julia 1.0 was released regarding scoping [1]. Beginners intuitively think of scoping in a manner different from the way scoping should work in production projects. There was a lot of tension between seasoned programmers and educators (who had to constantly interact with beginners).

The community exhausted the entire design space (along with some full-blown prototypes). Eventually, the core Julia team chose to use more forgiving scoping in the REPL (virtually always the first point of contact for beginners), while actual projects enforced stricter scoping rules.

My key take-away is to consider how the language interacts with its ecosystem, not just how it should ideally operate in isolation. I have found the Julia team to be consistent in this pursuit. If the first point of contact is intractable for beginners, the project is dead on arrival. A technical tool should be tailored for experts, but you don't want to kill adoption along the way. Engineering is tradeoffs.

This article goes more in depth along the same lines: https://pchiusano.github.io/2016-02-25/tech-adoption.html

[1] https://discourse.julialang.org/t/another-possible-solution-...

I understand there's a larger point being made here but I wouldn't give the decision that the Julia team made about scoping as an example of how to design a language. It makes the language inconsistent and now both beginners and experienced developers have to learn an exception instead of one group having to learn a slightly novel approach to scoping.

Allowing both seems like the worst solution. Inconsistency is annoying for both beginners and professionals.

>> My key take-away is to consider how the language interacts with its ecosystem, not just how it should ideally operate in isolation.

Please please, how do we convey this to the mathematicians that infest wikipedia?

I would love someone like gwern [0] to write an analysis of how Mathematics articles on Wikipedia start off being understandable by most and then get lapped into a submicron finish that only reflects an insular subset of folks. These mathematical nuggets sit like hard grains in mud (sorry wikipedia) that only mathematicians can understand.

And in so doing, they slowly bootstrap themselves so far away from any grounding context that it is incredibly difficult for anyone to _learn_ mathematics from reading wikipedia articles.

There are groups doing great things like Setosa [1], nLab [2] and for concepts, Simplicable [3]

[0] https://www.gwern.net/

[1] https://setosa.io/ev/

[2] https://ncatlab.org/nlab/show/HomePage

[3] https://simplicable.com/new/communication

I had not realized that was going on, but it makes a lot of sense now you mention it.

Yep Microsoft has the good habit of dogfooding its own products. All of Office 365 uses Azure AD for identity management.

I love how easy it is to view the machine code for a function. Julia actually ships with a handful of these introspection macros: https://docs.julialang.org/en/v1/devdocs/reflection/#Interme.... They are invaluable when it comes to optimization.

Indeed, inspecting typed code, lowered code, llvm ir, and native code from the REPL is great. Combine that with @benchmark for microbenchmarking and it's amazing.

Note that the 'manual dispatch' is optimized out in a very early stage:

    julia> @code_typed foo(1)
    CodeInfo(
    1 ─     return 2
    ) => Int64

So, no need to look at assembly here.

Prof. Alan Edelman gave a nice lecture about this a couple of days ago https://www.youtube.com/watch?v=IuOXXQR7dAo

"Language agnosticism" is an ideal I have never been able to attain. Sure, I can hack together a solution on the first week of learning a language. But, am I able to write elegant, idiomatic, efficient code during the first few months? No way.

A language is not just the basic control flow operations, but includes package management, performance gotchas, correctness gotchas, standard library, library ecosystem, data representation, etc. Then there are details and edge cases that you just don't hit without months or years of hard work with a language.

My experience tells me to take choose a reasonably robust language, then stick to that language until you have an overwhelmingly compelling reason to switch.

Vice made a mind-blowing series on this if anyone wants to see with their own eyes: https://www.youtube.com/playlist?list=PLw613M86o5o7a0FGlPRdt...