1,061 karma · joined April 11, 2019
There are invariants that you would like to be able to express as part of a specification for a process where the exact implementation is unknown at compile time. Further, the exact choice of implementation may depend on the runtime results of a previous step, requiring nested fexprs. There are many processes that are more naturally expressed in this way.
Consider for example trying to specify a function that transforms an environment from one where a package is not installed to one where it is installed. There are a huge number of ways that this might be implemented, and an fexpr can serve as a specification for the information that must be provided so that it can be carried out automatically, e.g. rather than specifying the name of the package, the name of the package manager, the name of the source repository, a dependency list, etc. that can all be ignored and instead a single function implementing install-package can be provided. Some of the simpler examples can be implemented using only first class functions and closures, however as soon as there are expressions where the evaluation of the arguments need to be deferred then you need fexprs.
The primary motivation for the idea was that there are tons of people out grinding in game money in single player games, and all that labor (leisure time?) is trapped in the game (yet somehow not creating disastrous inflation in-game ...).
What if there was some way that players could capture that time and (leisure labor)? At the time Valve was already trying to reward people for creating value for others, but what if we could just exchange the Skyrim dollars that we had earned from our single player playthroughs?
Well, here we are.
From a technical standpoint if there is existing functionality that is widely used and even if it is deprecated it should not simply be removed. Deprecation means that no new projects should make use of that functionality. Actively removing functionality without providing a path forward that supports the same features is a sign of an immature engineering culture.
Gentoo patches system pip to ensure that users don't fubar their systems. Some distros do actually know what they are doing, sometimes better than upstream. I would argue that distro python is so often broken precisely because the core solutions for python packaging are immature to say the least, and entirely deficient and poorly thought out to say the worst. This is likely largely due to the reliance on virtual environments which are the ultimate non-solution and allow the real problems to fester without a solution.
> all the breakage is dumped on distribution packagers.
This line sums it up for me. It is the fundamental disrespect for other peoples' time, and the lack of any attempt to maintain backward compatibility that goes along with it that have convinced me that the whole mindset around python is not suitable for any project that needs stability.
For example, I foresee a future where the academic python codebases that happen to have avoided the superfund site of jupyter notebooks will be broken and useless within a decade because no one will be able to install them and use or reuse them due to some as yet unforeseen change from upstream. The maintenance overhead of using python is absurdly high, to the point where it seems that every single project has to have an active maintainer otherwise it rapidly becomes completely useless.
Maybe it will get better, but it would require a significant shift in community priorities.
edit: Oh, don't miss the circular dependency introduced by tomli. You can just curl it onto your system right?
edit2: No more data_files? Wow. That's a disaster.
On the whole lineage does not imply capability, skeletal anatomy is not predict cultural level, etc. but because the great chain of being continues to drag our civilization down to its lowest basest form we belittle anything and everything that looks even slightly different than us. The fact that the null hypothesis in life sciences is that other species do not feel pain, do not have emotions, do not have cognitive process, etc. is derived from the abhorrent idea that only human beings have souls, or that the abhramic god gave man dominion over the animals. Is it a surprise then that some scientists have fooled the bigots by classifying everything as human? They know that by some criteria the lineages are sufficiently different to be classified as such, but there is no reason to give bigots ammunition for public policy.
0. https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-va...
1. https://news.ycombinator.com/item?id=21476261 (original 2019)
2. https://news.ycombinator.com/item?id=27639890 (revisited 2021)
In short a package manager + git is the easiest way to distribute and maintain software ... once you know how to use them. Configuring in a new environment? There is nothing that works reliably, other than maybe a full blown human level intelligent agent that is a senior developer with direct access to poke the system until it works.
Further, developers with little time or experience packaging software for regular users may balk at what they rightly perceive as a route that is more difficult and creates more work in the long run because as a dev you can't just drop a "fix pushed" message your messenger of choice and go back to work.
Static linking seems like it is a solution until you have to distribute to multiple operating systems. Only things like cosmopolitan libc have been able to overcome this, but even that requires a binary blob.
In long ....
I maintain a dozen or so python packages. Small stuff, mostly used by myself and my research group. At some point I needed to make some of that functionality available for other devs and some non-technical users. It was and is a massive pain.
Why was it such an issue? I think it is because many of the quick internal scripts were originally written assuming that only technical users as advanced or nearly as advanced as the author would be using them, and that any such user would be able to use git, configure their environment, and generally keep their system up to date using a package manager.
Aside. Add to that the fact that my dev environment is Gentoo, which has one of the sanest python environment management solutions available, and every time I step outside it or get reports from the poor lost souls trying to run my code "elsewhere" I enter a world of sanity destroying chaos. The workarounds that I created to try and mitigate some of the issues were poorly designed because I tried to YAGNI without realizing that you inevitably gonna need it (YIGNI?) and that the technical debt surrounding issues with interfacing with the environment is 10x more time consuming than anything else, especially if it is in the form of reports from souls lost in the warp.
Even if a dev can use git and a package manager they can still get stuck configuring the environment. Seems easy until there are secrets to distribute or someone needs to run something in a sightly different environment and nothing works.
For non-technical users it can be a stretch to get docker set up correctly, especially if they need X11. If I can get ssh access to the machine then there is a chance, but that doesn't scale beyond maybe 2 or 3 users. I have seen enough of this to have started to seriously consider just learning how to create installers for macos and windows and build them via CI. The long term solution is to switch off python completely, but the legacy code will continue to haunt us for a long time.
I've learned docker to try to create controlled environments. I've looked at statically linking SBCL to musl libc. I've looked into cosmopolitan libc. I've explored trying to use Emacs, elisp, and org-mode as another possible route to bootstrap stable and predictable environments. I've looked into Gentoo prefix. I've wondered whether I could get users to install Pharo, but realized that it is already a tossup whether they can get docker running. I'm so sick of having to repeatedly do searches in high dimensional configuration space (fight with the environment) just to get some random code to run for a user who can't deal with the configuration space themselves (and it's not their fault!). At this point it would be easier to wire all my users up to a mitogen botnet ... except that some of them use windows!
Telling a user "install python" or "install x" and then run this code leaves out the "and resolve the 10 completely novel errors you will encounter along the way." This is because there are at least 5 ways to "install python" (oh, don't forget the even bigger nightmare that is "install pip") on any given operating system (forget distros [0]), and each one results in a setup where things like data or configuration files are installed in different places with no obvious way to figure out where those places are, or you are forced to resort to a runtime lookup that causes CLI program startup time to explode to hundreds of milliseconds, making the entire point of having a quick CLI script moot.
Hello world may be the easiest program to write but it is by far the hardest program to run. Dependencies? Data? Network? Good luck.
https://groupbuys.mechboards.co.uk/shop/hyper-7-keyboard-r3/
This is harder to get good data for because it would require tracking individuals across time. The payoff is that it would likely reveal evidence of structural changes if such changes exist.
At the population level it is hard to tell whether and where changes are happening. Getting the transition probabilities would allow for more effective targeting of interventions (though most of the folks who work on this already know which transitions are the hardest to recover from).
The reason for this is that it forces the bad faith actor to enter the scene, they can't just slink away once the damage has been done and point back at the "doubt." It breaks the 4th wall in a sense, forcing the audience to realize that there is an active party with their own agenda in the scene.
Effectively all a scientist has to say is "The literature is an evolving work that reflects our current understanding. There are many factors that are involved in making public policy, and it seems that you are looking for a way to limit the influence that science can have on that policy to further your own goals that are driven by other factors that seem to be at odds with the public good."
It would be nice if they could also say "Anyone can read the literature for themselves ..." but unfortunately that is not currently the case.
This means that most of the time when dealing with adversaries you have to go against your usual scientific instincts, assume your position is correct, and reframe the conversation at a higher level about power, money, etc. Controlling where attention goes in these conversations is critical.
Refusing to engage adversaries at the technical level seems wrong, but is the only way to defend against the fact that science operates by default at a level of doubt that the normal population simply cannot sustain without being driven to apathy (which is the objective of the adversaries).
0. https://orgmode.org/list/CA+G3_POBAB1QX1Zv8q9sjFh4KHUHVmaNXp... 1. https://github.com/tgbugs/laundry/tree/next 2. https://news.ycombinator.com/item?id=28095196
There aren't any winners in steady state competition, that is, until your average run of the mill grey squirrel is introduced into regions (markets?) where the existing scatter gatherers didn't have any competition. Then they dominate and drive all the competition to extinction.
Sometimes capital accumulation can let a non-competitive company survive the market entry of a competitor that operates more efficiently in a way that is similar to how a species with a large population might have a few members that can compete effectively. But at the end of the day those fat margins will eventually disappear.
0. https://orgmode.org/list/CA+G3_POBAB1QX1Zv8q9sjFh4KHUHVmaNXp...
Sometimes I work in an Org file, sometimes in a lisp file directly. In both cases I will C-x C-e (eval-last-sexp) or run blocks, or the whole file (depending on Org vs lisp file). It is copy and paste on steroids (same for slime-eval-defun were you can be working deep inside some large function and update the whole without changing your view).
There are some examples of developing in the debugger in [0] around 55 minutes (linked). This video also has great examples of other crazy interactive development workflows and is worth watching in its entirety if you are interested in this kind of thing.
undo-redo is in emacs-28 now, though not the default behavior.
> Allow writing Emacs commands in popular languages like Python 3 or JavaScript.
For js see https://github.com/emacs-ng/emacs-ng
Integrating additional runtimes into the Emacs core, especially ones that also have a single main thread are likely to be a complete nightmare. There are already insane and undebugable performance issues with things that run on the main graphics event loop or on timers.
If elisp can somehow be made multi-threaded there might be a chance. However, there is SO much elisp code that assumes synchronous ordered execution that will break in subtle and unexpected ways when that restriction is lifted I expect it will take even longer than the transition to lexical scoping (and that is just in the core). I would love to be wrong though.
With respect to Python, the cpython runtime and semantics for redefinition are likely even more nighmareish because it is so easy for classes and instances to become out of sync and you wind up having to restart the whole environment just to clear out the bad state or risk creeping insanity. Also the churn in the Python ecosystem is likely far too high for Emacs to be able to maintain. So there are both technical and process mismatches. You could always run python in a separate process and use message passing though. Work to support LSP certainly paves the way for it, and elpy has fully interop with python as well, so you could use that machinery to operate on buffers in languages beyond python. So if all this is possible why isn't anyone doing it?
nervous system
-> central nervous system
-> brain
-> spinal cord
-> peripheral nervous systemThis is a comprehensive review of human factors affecting interaction with nearly any "formal" system where "formal" means anything from a color wheel to a prolog database.
I have repeatedly encountered these issues while working on a formal language for specifying scientific protocols. I knew I had my work cut out in terms of finding a way to create an interface that non-expert users could work with, but this makes it clear just how critical it is for the tools not to distract the user from their expert thinking.
This poses and incredible design challenge, and that is without any discussion of variability between users!