HNHacker News
TopNewBestAskShowJobs

tgbugs

1,061 karma · joined April 11, 2019

submissionscomments
tgbugs··on Large Eruption Near Tonga, Heard in NZ. Tsunami at Tonga and Fiji
It looks like there was another eruption in a volcano north east of there the day before?
tgbugs··on On Pitman's “Special forms in Lisp” (2011)
The fact that fexprs are not easily accessible in the major lisp and scheme dialects is quite unfortunate because it makes it difficult to express certain process structures. Like with all advanced language features they would have to be used carefully, but from reading Shutt's discussion of fexprs and interpreters it seems that adding them would move a language to nearly complete expressiveness.

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.

tgbugs··on Game Studios Are Turning Play into Work
It was just an example of a game that people sink lots of hours into, and yes, way too much gold, to the point where you are swimming in it even if you aren't trying to grind it. There is also the issue that you can break the crafting system to create single potions that are worth hundreds of thousands of gold and that should probably cause the game universe to be sucked into a black hole, but that is a separate issue.
tgbugs··on Game Studios Are Turning Play into Work
"Skyrim dollars" was a concept that my friend group roundly pooh-poohed when I brought it up in a late night rant some time around 2012. Over time it has become something of a meme, but this winter break we were all sitting around and realized that Skyrim dollars have become hot new tech.

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.

tgbugs··on On Emacs 28’ context menu and Unix mouse-usage in general
This is a useful practical introduction to the new context menu functionality. Since power users rarely use the mouse or right click at all, I have found that context menus are a great space for making custom functionality accessible to semi-technical users on a file by file basis. Yes, this breaks all sorts of usability guidelines related to consistency. On the other hand if used judiciously it can save the user an enormous amount of time by giving the a single place to look for functionality that is relevant to them in a given context.
tgbugs··on Gaming on Wayland
Their developers to implement some dbus protocol probably?
tgbugs··on The future of Python build systems and Gentoo
They should care because their behavior is a strong negative signal that they don't care about supporting existing users and taking responsibility for code that they have written and supported in the past and because it will ultimately cost them users and contributors.

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.

tgbugs··on The future of Python build systems and Gentoo
Sigh. I deeply appreciate the work that Michał does. This post signals a bunch of work that I will have to do in the future to mitigate the eternal churn in the python ecosystem.

> 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.

tgbugs··on Too many species have been lumped together into Homo sapiens
Criteria for being classified as human are diverse, most of the criteria we use for classifying living people (some of which are actively being used to commit genocide) cannot be applied to our ancestral lineages, we give our genes too much credit relative to our memes, and cladists will use whatever evidence they can find to support their cladism. If the splitters in the lumper splitter debate are using splitting as an excuse to murder and disenfranchise people then it is hard in good conscience to openly articulate the truth and ethically is probably better to attempt to slow the splitters' efforts by confusing the whole field with alternate hypotheses.

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.

tgbugs··on On Hubris and Humility: developing an OS for robustness in Rust [video]
For those looking for more on "parse don't validate" mentioned in the talk here are links to the original, and two previous discussions.

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)

tgbugs··on Common Infrastructure Errors I've Made
I have the same issue. I'm pretty sure you can dig through my post history and find a blanket statement of me swearing off python for all new projects. Here are some ... reflections.

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.

0. https://repology.org/project/python/packages

tgbugs··on Keymacs: Modern Symbolics-Style Keyboard
For comparison there is the Hyper-7 r3 which is a very large keyboard, but has some similarities in layout [0].

https://groupbuys.mechboards.co.uk/shop/hyper-7-keyboard-r3/

tgbugs··on In-orbit demonstration of an iodine electric propulsion system
I look forward to seeing more methods sections which have a step that involves launching things into orbit. I bet that at some point the exact type of rocket that is used will cause variable results due to differences in the vibrational modes modifying payloads so that their behavior changes.
tgbugs··on Breakdown of data on homeless populations across the U.S.
One piece of analysis I'd be interested to see is whether the transition probabilities among the 4 categories along with the implied 5th category of "not homeless" have changed.

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).

tgbugs··on I'm “still afraid to use spaces in file names” years old
Yeah, the physical layout is the primary concern. I should have noted that since there is ambiguity because n and m also happen to be next to each other in the alphabet.
tgbugs··on I'm “still afraid to use spaces in file names” years old
Word of warning from hard experience: rn is a really dangerous thing to name a function because it is one char away from rm.
tgbugs··on How Industry Weaponizes Science and Sows Doubt to Serve Their Agenda
A recent related discussion https://news.ycombinator.com/item?id=29084104.
tgbugs··on Scientists: Don’t Feed the Doubt Machine
Heh, yeah. We need to add another class to the ethics courses. "How to interact with parties who would be politically or economically impacted by the results of your research."
tgbugs··on Scientists: Don’t Feed the Doubt Machine
I actually think forcing someone acting in bad faith (to use the sibling response's nomenclature) to accuse scientists out loud and directly in such a way is the right approach here.

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.

tgbugs··on Scientists: Don’t Feed the Doubt Machine
Said another way, don't get nerd snipped by people who are trying to weaponize your professional scepticism for ulterior motives.

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).

tgbugs··on Org Mode 9.5
See also [0, 1] from previously [2].

0. https://orgmode.org/list/CA+G3_POBAB1QX1Zv8q9sjFh4KHUHVmaNXp... 1. https://github.com/tgbugs/laundry/tree/next 2. https://news.ycombinator.com/item?id=28095196

tgbugs··on Is Competition for Losers?
An organism, individual, species, company, etc. can survive effectively via adaptive radiation into niches where there is less, little, or no competition. This is an effective strategy. However, at a certain point lack of competition leaves them vulnerable to another species, company etc. that has evolved under intense competition.

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.

tgbugs··on The NSA's Backdoor in Dual EC
Huh. I had not though of the rekeying issues before. Glaringly obvious in hindsight. The question of "how can you ensure that this system will not be rekeyed to respond to someone else" is a great one. The best answer is "there is nothing that can be rekeyed."
tgbugs··on Chicken Scheme
I would love to be able to use chicken on a regular basis, but unfortunately it is an enormous pain to get it install on a system at the same time as mono because the mono c# compiler and the chicken scheme compiler have the same name [0].

0. https://bugs.gentoo.org/645728

tgbugs··on The open calendar, task and note space is a mess
We're working on a formal grammar and a test suite that can be used to specify expected behavior. See the linked mailing list thread [0] for pointers to some of the interested parties.

0. https://orgmode.org/list/CA+G3_POBAB1QX1Zv8q9sjFh4KHUHVmaNXp...

tgbugs··on Hell Is Other REPLs
The workflow for slime/sly and swank/slynk described at the end of the article is standard if you are in the Emacs world.

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.

0. https://youtu.be/bl8jQ2wRh6k?t=3299

tgbugs··on Emacs Modernization: Simple Changes Emacs Should Adopt (2006)
> especially 'redo'

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?

tgbugs··on Friendship ended with the garbage collector
This is not accurate. The SBCL runtime and GC are written in C because there are better tools in C for debugging the kinds of errors that one encounters at that level of the system. I can't find the note in the SBCL source repo but if you dig around a bit you will find it.
tgbugs··on Mental phenomena don’t map into the brain as expected
The top level partonomy for the nervous system is usually as follows.

  nervous system
  -> central nervous system
     -> brain
     -> spinal cord
  -> peripheral nervous system
tgbugs··on The Use of Formal Representations in Interfaces (1999) [pdf]
Thank you for sharing this. It is somewhat staggering to come across a paper that so perfectly captures that problems that one encounters, and discover that it was written nearly two decades before.

This 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!

← PreviousPage 4 of 9Next →