funcDropShadow

Yes, nixpkgs is definitely missing the self-documenting part, or even the documenting part for most of it.

Don't forget the self-documenting aspect. The manual is included, the api documentation is included, you can ask emacs which command is executed when you click somewhere or when you press a button. I recently tried to do the same thing in Intellij, pita. Not only, can you find documentation, you can jump to the source code, inspect variable values at runtime, and debug or profile everything. All of that from inside the environment.

Dynamic scoping is a feature in the Emacs ecosystem. It plays a similar role to dependency injection in other languages. It is what allows you to change global state for some function call. Dynamic scoping together with buffer-local, file-local, directory-local variables is similar to scopes in dependency injection libraries --- a powerful organizational tool.

In practice it is difficult enough, to do the right date arithmetic using the datetime library in the right timezone.

There is a central configuration, see here https://news.ycombinator.com/item?id=43642743

One way to deal with large binary files is git-annex, it is as decentralized as git. But I dare say it lost to git-lfs, because Github and co weren't interested in hosting it.

In a hierarchically system renaming a directory is an O(1) operation, in a non-hierarchical system with paths it is an O(n) operation.

Object stores are not filesystems. They have a paths, but they are not hierarchical.

Yes, the history of the name is as you write. But the value of the command lies in finding the commits, and, especially, in finding which lines changed together.

Is tee.exe supposed to be the normal tee unix tool?

> True, but I suspect it'll be a lot easier to virtualise all those APIs through WASM than it is for a regular native binary. I mean, half the point of docker is that all syscalls are routed into an LXD container with its own filesystem and network. It should be pretty easy to do the same thing in userland with a wasm runtime.

All of this sounds too good to be true. The JVM tried to use one abstraction to abstract different processor ISAs, different operating systems, and a security boundary. The security boundary failed completely. As far as I understand WASM is choosing a different approach here, good. The abstraction over operating systems was a partial failure. It succeeded good enough for many types of server applications, but it was never good enough for desktop applications and system software. The abstraction over CPU was and is a big success, I'd say.

What exactly makes you think it is easier with WASM as a CPU abstraction to do all the rest again? Even when thinking about so diverse use-cases like in-browser apps and long running servers.

A big downside of all these super powerful abstraction layer is reaction to upstream changes. What happens when Linux introduces a next generation network API that has no counterpart in Windows or in the browser. What happens if the next language runtime wants to implement low-latency GC? Azul first designed a custom CPU and later changed the Linux API for memory management to make that possible for their JVM.

All in all the track record of attempts to build the one true solution for all our problems is quite bad. Some of these attempt discovered niches in which they are a very good fit, like the JVM and others are a curiosity of history.

Nothing is intuitive on its own. Intuitiveness is a property of the relation between a thing and and some subject. Whether `map` is more intuitive than `then` depends on that subject. Without assuming a target audience, it is futile to design a library to be intuitive. Intuitive is that, for which we already have built an intuition.

One purpose of science is to provide the rest of the society, who are not scientists, with reliable insights, ideally with actionable advice on how to solve a problem. If you treat science purely as a stong-link problem, the burden of quality control lays with the consumer of science. Peer review attempts to lay it with experts. That approach is nowhere near perfect, but is the best we have. And it scales much better.

Then, why is Doge flagging things like funding gender-change surgery abroad instead?

You don't have to wonder. Just observe what is going on in so-called liberal democracies of the world while identity politics is implemented by governments: censorship, redefinition of words, inventing new moral issues to shutdown inconvenient facts and such.

Which debuggers do you like the most?

As someone who has been using emacs for almost 30 years. There are lot's USPs for emacs, but none should matter for the selection of a programming language. I hear lots of good thing about Calva, a Clojure plugin for VS Code. Look at that if you want to try out Clojure in the form of Jank.

Didn't Mark Zuckerberg say he would reduce censorship on FB just a few weeks ago?

My observation with the Scala and Haskell ecosystems has been very similar. One primary source of churn is changing interfaces. And very advanced static type systems offer a large design space how to model interfaces. Which leads to lots of incremental improvements. But lots of interface changes together with deep dependency trees lead to exponential explosion of changes.

Rich Hickey has been discussing this very early, but almost nobody got it when he said it, myself included. Striving for obviously simple interfaces, that avoid nominal static types like the plague, is the way to avoid this often pointless waves of changes through language ecosystem, just because someone designed a better option monad or whatever.

Unless you have a very good JIT compiler, like JVMs. Than you can defer LTO and whole program optimization to runtime.

Could you recommend some resource to understand this view of accounting better?

The technically correct term -- at least in reduction systems -- would be confluence not convergence.

Theoretically, using fractionals as list labels requires unbounded amounts of memory to store the fractions. In practice that is extremely limitted. But the difference becomes really a problem. If you are not just assigning ordered labels to a collection, but if you want to use these labels directly as array indices to store the elements. That would be a more literal modelling of the library sorting problem.

In firmware interfaces you can configure whether USB and PCI-E devices can wake up the computer. Enabling USB wakeup made it possible on my machine, that I can wake it up by pressing any key on the keyboard.

Some beg to differ: https://www.youtube.com/watch?v=u-7qFAuFGao

Because Apple invented this kind of walled gardens.

The abstract says the code will be available.

This slows down innovation.

In Java it is common to use the MDC support of slf4j. You can add to metadata in thread local variables, so that you don't have to add it at every logging site.

Probably, a hierarchy of different loggers.

Why do you prefer Log4j2 over the slf4j api and why over logback as the backend?