HNHacker News
TopNewBestAskShowJobs

tgbugs

1,061 karma · joined April 11, 2019

submissionscomments
tgbugs··on Brain images just got 64 million times sharper
The number in the title is misleading but what you write here is also misleading.

> The diffusion tensor images (DTI) @ 15 μm spatial resolution are 1,000 times the resolution of most preclinical rodent DTI/MRI. Superresolution track density images are 27,000 times that of typical preclinical DTI/MRI.

The resolution of the raw MRI images is significantly higher, without that increased resolution it would be impossible to align the light sheet images. The light sheet images are not use to "improve" MRI resolution.

tgbugs··on Most of us won't be inventing little languages (2004)
The problem with object oriented languages is that they are fundamentally compositional in their use. You have to know all the relevant pieces (objects) for solving your problem and how they all fit together. They are very powerful for solving complex problems, but they require significant expertise to employ.

On the other hand, if there is a small DSL that can express the problem at the level of surface syntax instead of a full compositional system then it is much easier to learn, check, and correct. That full compositional system may be what sits behind the language as the semantic layer, but having it be the only interface without any syntactic support is unhelpfully opaque for new users.

tgbugs··on Hundreds of changes made to latest editions of Roald Dahl's books
I prefer waux, as in faux.
tgbugs··on Statement on President Carter’s Health
When I was a child I was at a Duke graduation event, and was sitting around waiting for it to end so I could go play, and a old guy sat down next to me and said "Hi! I'm Jimmy. Who are you?" and proceeded to talk with me for the next 30 minutes or so.

I had no idea who he was, and I have no memory of the conversation, but I have been told that he was relieved to find someone to talk to with about anything other than politics.

Thank you for keeping a little boy entertained on a summer afternoon long ago, among the countless other things you have done to make the world a more welcoming and caring place.

tgbugs··on I love building a startup in Rust but wouldn't pick it again
I had a similar thought a while back [0]. Developing a sane ontology of error types and their implications is a hard problem, but I think it could be done. The subset of errors that is the most frustrating and hard to deal with are ones where, as you point out, the client will have no way to estimate how long a failure mode might persist, at which point you resort to exponential backoff (actually probably an s-curve).

The issue is that sometimes the solution to the issue would require the client to get up and get out a shovel, and go dig somewhere or something. When the abstractions break down that hard there isn't really a way for the developer of the code to handle that unless they somehow stuff a full blown AGI into their program, and even then it would be a stretch.

0. https://github.com/tgbugs/idlib/blob/master/docs/identifiers...

tgbugs··on Polymode: Multiple Major Modes and How to Use SQL and Python in One Buffer
If this has good enough performance it could be a big deal for org-babel. We've struggle to implement good/sane editing of blocks in the same buffer, and popping out to another buffer is a hacked workaround most of the time.

Will definitely give this a spin.

tgbugs··on The Yaml document from hell
My distaste for yaml led me to attempt just that. The first piece that was missing for me was a python parser that could produce reasonable error messages and could be transformed into the desired internal representation in python. So I wrote one [0]. It was supposed to be a single file that was less than 100 lines and could be copied and pasted into any project that I needed. Turns out that the issue was a bit more complex.

The issue is that there is sufficient complexity in finding a portable representation for configuration formats that it just kicks the can down the road. On the other hand it means that as soon as you decide what format you are going to support you can quickly implement it. There is more or less a intersectional grammar that works across most if not all lisps, and that is the plist `(:k v :k2 (:k3 v2))`. So I settled on that for my own use.

After all that work I have not dealt with the fact that numbers and chars do not have a portable representation across lisp dialects, which is a key complaint in other threads here. Limited support for let binding constants also seems like a feature that would allow for just enough expressivity to make the format useful without opening up the terror that is `&` and `*` in yaml (cool and useful as it may be).

In summary s-expressions are: 1. missing good parsers in a number of language ecosystems 2. not standard across lisp dialects 3. need additional semantics for binding, multiple expressions, etc. 4. still better than yaml and json

0. https://github.com/tgbugs/sxpyr

tgbugs··on Explicit Ontologies in a World Without
The key problem with trying to use LLMs as a proxy for ontologies is that you have to figure out what ontology the LLM is actually using if that is even possible in the first place, because LLMs should in principle be encoding multiple perspectives.

If all you want is search and retrieval, that might be ok. Otherwise, you are right back where you started with multiple implicit ontologies that individuals and groups struggle to reconcile.

However, there is a much deeper problem that is faced by ontologies, whether they are implicit/explicit, trapped in an LLP, or written in OWL, and that is that ontologies are best thought of as collections of hypotheses which must be tested and testable in order to be useful and verifiable. We are only now starting to think about how to get formal ontologies into the loop for validation based on observable data in the life sciences (beyond say, pointing the the literature).

LLMs can generate so much garbage that validating any latent ontology they may contain is likely to be both absolutely critical for them to be remotely useful, and also extremely difficult/labor intensive, bringing them right back down to reality when it comes to the difficulty of validating and verifying them.

In the end, formal manual ontologies look hard because they tend to put the validation of the model first. LLM pseudo ontologies might look easy, but the cost of validating and verifying them will likely be almost exactly the same in the end (if not worse).

The reason for this is that the real cost is reconciling a model with reality and having strong control over what constitutes valid data about reality, or making the measurements on the real world to verify some statement.

LLMs might help when it comes to coverage of a domain, but if that coverage is achieved by also having 80% of all statements being demonstrably false and leaving it to the users to determine which 20% are true, then the coverage probably isn't worth it.

tgbugs··on Someone is pretending to be me
I had to review a number of developer resumes from a similar site back in 2020. Reading through them absolutely set off my "this is a fake person" detector. The resumes had similar formats, they all seemed to point to a real person, but there was a lingering sense of similarity between them which was too much to account for. I though it might have been because the site provided a way to create resumes and they were all choosing from some common set of options or something like that. However, reading this account makes me think that a scam like this is an equally likely explanation.
tgbugs··on Edge Case Poisoning (2020)
When doing this for scientific protocols I found that you basically have to give up any hope of specializing types of things. The domain ontology for documenting processes, be they making cupcakes or electron micrographs, has to be matched to the domain in question.

Some might say that for processes this means everything must be extremely abstract in order to avoid edge cases like those encountered by the author. However, I would argue that from the perspective of someone executing a recipe they do not care at all about whether something is edible or food or not, they only care how much they need of something (count is a unit(less) of measure). Thus, the ontology proposed by the author is not matched to the domain.

The first mistake was trying to make a distinction between food and non-food. What if I used paper cupcake cups? They may not technically be food, but I have certainly eaten parts of them before by accident. Other parts of the system might care about food/non-food, but these parts are constrained by a separate and likely orthogonal set of use cases.

I don't usually need to know the chemical formula for sodium bicarbonate to order it from a vendor, but if I need to automatically calculate stoichiometry for reactions so that I can automatically order the correct amount then I might. Those two parts of the system can and should be completely orthogonal to each other and thus fully decoupled.

Therefore, I would suggest that encountering something that looks like "edge case poisoning" is a sign that you have not properly factored the system.

tgbugs··on Jonathan Blow on Societal Collapse (2019)
I think there is an additional possibility, which is that the software quality is bad enough, but there is no where else for users to go.

Since proving that directly would require a viable competitor to already exist we are in a bind.

However, we might be able to find some examples where there are viable competitors, or we might be able to find a population of users who have enough experience with similar pieces of software to be able to state which one has fewer bugs (at least for their usual workflows).

One category of software that comes to mind for me would be 3d modelling and rendering software. Perhaps examining the impact that Blender has had on quality would be a place to start?

edit:

I do think that the activation energy (capital) required to get competitors off the ground at this stage is enormous, but that is in part because many of the alternatives have been allowed to die out or be acquired by their direct competitors. Had they been kept alive an independent there would not be a need for so much capital to get back in the game. Sadly, now, many years on, the remaining systems have acquired enough complexity that they can fend of most competition without much effort.

tgbugs··on Jonathan Blow on Societal Collapse (2019)
I'm oversimplifying a bit here, but I think the strategy that most major software firms are following right now would match the "adaptive radiation" phase of ecosystem evolution. There are so many empty niches as a result of the high dimensional space of user requirements (where say, 2 additional features are sufficient to differentiate a product, see e.g. discussions about slack vs discord vs teams from today) that companies hardly need directly compete with each other. This would be a virtuous explanation for lack of competition.

Another candidate explanation for what is going on in your "race to the bottom" likely has to do more with signal to noise issues and other types of adverse selection where e.g. a company needs to spend only just enough money for a product to make it past the average review date, at which point the device/whatever will fail. These literally marginal devices/software/whatever are then sold by literally copying and pasting the specs from some other product that is selling well and now consumers are toast. In the software world this looks like a billion clones of the same game, etc. This however is not what I would call good faith competition, and in biological systems species that do this eventually get wiped away completely when they finish degrading the ecosystem they are in. This will look like a mobile gaming crash (about which there seem to be some google hits for back at the start of August).

The kinds of things I'm thinking about are e.g. the fact that text selection in HTML documents is SO BAD that people have started to add copy buttons. Want to copy a url out of some calendaring software? OOPS NO you actually wanted to select literally all the other text on the page right? There are what 2.5ish major browser vendors (supposedly) now? That is by design and a sign of anticompetitive behavior.

Another example would be the GTK+ file picker. Though in this case it is far more likely that the desktop linux environment is extremely marginal in terms of capital than anticompetitive behavior on the part of redhat.

tgbugs··on Jonathan Blow on Societal Collapse (2019)
If this is the case then it means that there is no competition in the ecosystem and that the regulators need to start busting monopolies and other anticompetitive behavior.

In a competitive market where there is actually free entry and free exit and consumers are not locked in there should be no such thing as diminishing returns at the level of brokenness we see here, unless we somehow think that writing functioning software is somehow impossibly difficult.

tgbugs··on Soft deletion probably isn't worth it
One use case that I think is not sufficiently considered in this is related to two comments I made about a year ago [0, 1].

If you can _actually_ delete something, then that means that a malicious actor can fabricate data an claim that you deleted it. GDPR may be well intentioned but systems that have the ability to remove any record of a thing lay the groundwork for systematic fabrication of data, because any record of the past has been erased.

Operationally, I can totally see why soft delete might be considered to be problematic in certain cases, but from an information security point of view I think it is absolutely critic for protecting users against a whole class of attacks.

0. https://news.ycombinator.com/item?id=27249738 1. https://news.ycombinator.com/item?id=27691442

tgbugs··on Detecting unauthorized physical access with beans, lentils and colored rice (2021)
This thought crossed my mind, but I couldn't figure out quite how to get it to work. I think the fundamental flaw with using a deterministic process to create the state is that an adversary can immediately reproduce a matching system if they make the measurement, and then we are back to needing a deterministic process that takes longer to occur than transit time.

After a bit of tangentially related thinking (see below), here is one possible way, and why I don't think it works. One could deterministically create a metastable state in a quantum system, e.g. by pumping a certain specific amount of energy into it. Then to figure out how much energy there was present, any additional amount of energy from by the measurement would cause the state to collapse. Unfortunately having the measured value in hand an adversary could now reproduce that state because the original process is deterministic.

For example, a classic "easy to produce hard(er) to measure" is creating aqueous solutions, where a bunch of different solutes are mixed together (I always think of ACSF, artificial cerebrospinal fluid, because I used to have to make it all the time). The creation of these can be entirely deterministic.

Unfortunately all you need is a good analytical chemist to get an approximation. Even if you used specific ratios of different isotopically pure salts they could probably reproduce it, and you would want something that would cause an irreversible change on physical tampering, such as an oxidation, cleaving, or isomerization so that you couldn't just dump the contents and put them back. All of these are tactics that delay an adversary by presenting them with a measurement and combinatorial problem, but doesn't provide the "measure once" property we need.

tgbugs··on Detecting unauthorized physical access with beans, lentils and colored rice (2021)
I wonder whether it would be possible to use isotopic ratios of gases in negative pressure containers or something like that to ensure that any puncture will disrupt the mixture before it can be measured. Hardly foolproof, but anything that an adversary can measure you have to assume that they can reproduce unless you have some way to prove that the process required to reproduce that physical state _must_ take longer than the transit duration.

The other thing that comes to mind would be quantum systems that can only be measured once. Unfortunately I think that practically you would need a system that is "only twice" so that it can be compared, but I have this sense that anything that can be measured twice can be measured 3 times.

Lots of great links here to people working on practical solutions, but in the limit I wonder whether for many of the "black box in enemy territory" models you just have to go with self destruction as the only safe solution because anything less than a fully trusted human being is at risk for being tampered and pwnd (and even then you might still worry).

tgbugs··on Detecting unauthorized physical access with beans, lentils and colored rice (2021)
As a giant identifier nerd, this is incredibly cool. Any insights/thoughts on tamper resistance/non-duplication? I realize that this is a bit outside the original use case/threat model, but would it be possible to ensure that any physical injury to the coating would ensure that the code would no longer match? Seems like a challenge because you want robust matching but not robust enough to allow someone to substitute or reproduce the exact pattern.

I'm fairly certain that this cannot defend against a determined adversary buying up a bunch of pills, reading out the ids, and then reproducing the patterns (which would already be in the database) or similar enough patterns via a non-random process. Only useful for substitution attacks where someone trusts a pill because it is in a database without realizing that its contents could have been substituted for e.g. poison.

This may be obvious, but it also seems critical for any database that might use these to have expiration dates, otherwise expired pills could be bought in bulk and resold or have their codes reused.

tgbugs··on Many researchers were not compliant with their published data sharing statement
The NIH has mandated that starting in 2023 all grants that it funds must include a plan for data sharing. A serious lingering question is whether there is actually going to be any enforcement, given that it is already a monumental challenge for investigators to even account for the data that has been submitted/shared/archived by their lab, forget some 3rd party trying to do it.

The tools for doing this across a whole diverse ecosystem are shall we say not user friendly (if they exist at all), and that is being charitable (and I say this as someone who has written some of those less than user friendly tools). Most of the systems, archives, etc. are not interoperable, they don't share common APIs, much less have some common interface that would allow someone to track all their published data, forget integrate it.

Program officers are going to be desperate for ways to account for this stuff, but I worry that at least initially they are not going to have the leverage needed to get researchers to engage in even the most basic data management practices which would allow them to start solving the problem down the line.

How many files did you upload to archive X? Which project were they for? How many datasets are you expecting to produce for this grant? You have published 10 papers associated with this grant number, where are the datasets that correspond to those papers?

Some investigators can answer these immediately and easily, others will throw a screaming fit that they were even asked for such a thing.

tgbugs··on Science needs more research software engineers
For this to work academic science would have to start paying significantly more, which many labs simply cannot do, and other labs will refuse to do.

My PI flat out said when we were trying to hire a python developer that they simply could not be paid 2x more than anyone else because it would cause major issues with team cohesion. 2x is the bare minimum to even get close to market rate for a full time developer who won't dance out the door a year later.

By this logic either everyone in science needs to get a massive raise (stop to the PhD slave labor?), or rse's really have to justify their salary, and when everyone else works 60-80 hours a week for half the pay and is also defacto on call, that justification looks like zero work life balance.

Talk to a funder near you, let them know that congress needs to provide more money for basic research. Be sure to sell it as training future employees for big tech too since they will all eventually leave after you finish teaching them.

tgbugs··on A vision of a multi-threaded Emacs
One big challenge for multi-threaded Emacs is that there are many elisp libraries and common patterns around buffer modification that make implicit assumptions about sequential and exclusive execution.

The various race conditions that would appear in a multithreaded context would be a nightmare to debug because they would likely only occur sporadically and would be hard to reproduce. I would love to be wrong about this, but I see it as a major obstacle that will likely need to be sandboxed (as was done with lexical scoping).

For an example of how hard these kinds of issues could be to debug look no further than the incredible difficult that the undo-tree author had in debugging a race condition with the garbage collector. It took years.

In the context of this piece, having a buffer mutex makes certain use cases for multi-threading impossible, for example dividing the buffer up into chunk equal to the number of cores and running a regexp over each chunk.

tgbugs··on Moving a macOS window by clicking anywhere on it
Thanks for the pointer.
tgbugs··on Moving a macOS window by clicking anywhere on it
I've had `OnWindow Mod1 Mouse1 :MacroCmd {Raise} {Focus} {StartMoving}` in my fluxbox keys config for a decade or so? My brain will automatically issue and alt-click on a window in some other OS and I'm always jolted back to the reality that I'm not in my usual window manager. Now if only I could rebind that cmd ctrl on macos to alt.
tgbugs··on Tree-sitter grammar for org-mode
We're in the middle of updating the org syntax document. I've been preoccupied and haven't gotten a chance to take another pass, but there should be a new version out in the next month or so. See also [0].

0. https://github.com/tgbugs/laundry/tree/master/laundry/gramma...

tgbugs··on Everything we're told about website identity assurance is wrong
I've been coming around to the idea that the threat models that are often used for website identity are not the ones we want. The ssh threat model related to changes in host keys seems to me to be a better one.

The first time you connect to a website you get whatever identity it wants to show you. Whether it is a real site or not doesn't particularly matter, it only matters when the identity changes. If my first access was MITMed and then I connect to the "real" site, I should go and check to see what information changed, and if I sent any sensitive information I should probably do something to mitigate that (the exact action would depend on the exact type of info you sent). In the reverse case where you trust the original identity more than a changed identity you would ignore the event and might possibly want to inform the original entity that someone is trying to impersonate them.

Still fairly complicated for the original user, but certificate expiration would no longer be the insanity that it is now, and you can at least get transport security without the big scary self signed warnings that show up now.

tgbugs··on Nyxt browser annotations beat pen and paper
In case you are unaware there is https://hypothes.is which might fit the bill. It has the same issue with sparseness of annotations that you mention for epiverse, but I don't see any way to avoid that.
tgbugs··on Common Lisp ASDF maintainer considers resignation
You have it backward. This is installing a red light in the middle of a road where there is no intersection because 10 years from now there is a plan to build a crossroad and then wondering why people are angry about a traffic jam in the middle of nowhere. People who ignore warnings are the people who run new red lights and will eventually kill someone when the intersection goes in. The people who upgrade them to errors stop at red lights, don't kill anyone, and get rightfully pissed that someone put a red light up 10 years too early.
tgbugs··on Common Lisp ASDF maintainer considers resignation
There is one school of software engineering which upgrades all warnings to be errors and thus fatal because "warning culture" leads complacency. Thus emitting a new warning as part of default behavior will break builds.
tgbugs··on Common Lisp ASDF maintainer considers resignation
Not quite. The analogy is present explicitly in the gist but the comparison isn't particularly useful for understanding the social dynamics of the situation here.
tgbugs··on Common Lisp ASDF maintainer considers resignation
Another TLDR would be;

ASDF-stable is good enough that there isn't an incentive to update to a version of ASDF-devel that breaks backward compatibility.

tgbugs··on Common Lisp ASDF maintainer considers resignation
For (way) more context see https://gist.github.com/phoe/7d24bdb1f2be76a02fecba8cfecbef3...
← PreviousPage 3 of 9Next →