HNHacker News
TopNewBestAskShowJobs

tgbugs

1,061 karma · joined April 11, 2019

submissionscomments
tgbugs··on How Tech Loses Out
The real trick will be to make sure that the AI negotiating on your behalf is really your advocate and has not somehow been subverted (by any variety of means).
tgbugs··on A Primer for Decentralized Identifiers
I find the choice to use ownership language strange. The url/uri based systems are fundamentally inadequate for many if not most of their current use cases (they are not and never were intended to be persistent), and as the authors point out, there the urn system requires a central authority. Thus there is a need for some other system.

The ability to claim and prove authorship and determine the provenance (or tampering) of an identified document is crucial. For the most part people bindly trust that the nytimes.com that they are seeing is the real one, but there are so many ways that the can be compromised it is hard to comprehend.

More importantly, the current ways of protecting oneself against such issues are no longer accessible to the common man except via an interaction with some giant corporate edifice that they also have to trust. If you want to publish a document and distribute it in a way that its integrity and authorship can be determined there aren't good options.

Even more more to the point, there is currently no way general way to give a link to such a document that can be dereferenced to an untrusted host in such a way that the integrity of the document can be verified.

I supposed we could all share magnet links and check that they were signed with the nytimes pgp key, but then we are back to the issue of how to determine and distribute the nytimes pgp key. The WOT doesn't work, and pgp fails for anonymous publishing. Maybe the infrastructure behind DIDs will be able to solve the problems with WOT.

It will be interesting to see what comes of this, but I'm wary of its adjacency to the blockchain buzzwords.

tgbugs··on Bringing GNU Emacs to Native Code (2020)
See my comment about TRAMP and file system operations from a couple of months ago for some of the underlying issues.

https://news.ycombinator.com/item?id=25626412

tgbugs··on Emacs Lisp book revived: Marcin Borkowski
Not sure if this is quite what you are looking for, but I found reading through GNU Emacs: Creeping Featurism Is a Strength (chapter 11 of Beautiful Architecture) at the suggestion of Eli Zaretskii to be extremely useful at painting the picture of the environment in which elisp code runs and the assumptions that it makes.
tgbugs··on Category theory is a universal modeling language
I got into informatics and ontology because I stumble across David's paper on ologs. Years later and I'm still waiting for someone to implement a knowledge representation system that uses them, and hoping that it won't end up being me.
tgbugs··on Trans-Pacific deteriorating, brace for shipping ‘tsunami’
And here I am worrying about how to bootstrap programming language implementations. "What would happen if maven central suddenly disappeared from the face of the earth?" seems positively quaint.
tgbugs··on Linux Foundation’s demands to the University of Minnesota
I was on a road trip with 3 engineers this weekend and we were discussing this. I mentioned that I, along with nearly every grad student in life sciences is required to take a research ethics course because NIH training grants mandate that any student funded on the grant take an ethics course.

They all said that they wish that their graduate programs had required them to take an ethics course. One of them (from India) also noted that basic concepts such as plagiarism are assumed to be understood at the graduate level in the US, but that few students coming from Asia have received any orientation to ethical academic practice for students, much less researchers.

I don't know enough about how CS and engineering graduate programs are funded, but it seems that NSF is not funding very many programs, given that they do seem to require such training https://www.nsf.gov/bfa/dias/policy/rcr.jsp.

tgbugs··on “They introduce kernel bugs on purpose”
Wow. That is a flagrant violation of research ethics by everyone involved. UMN needs to halt anything even close to human subjects research until they get their IRB back under control, who knows what else is going on on campus that has not received prior approval. Utter disaster.
tgbugs··on Shadow Simulator – run real applications over a simulated Internet topology
A quick look (by searching for bgp) suggests that this handles the upper layers, but doesn't try to simulate some of the deeper layers of a network such as bgp. Which something that emulators like core can do [0].

0. https://github.com/coreemu/core.

tgbugs··on The Sisyphean Task of DNS Client Config on Linux
An enlightening article that explains why I think I am losing my mind every time I try to get the network configured correctly on any number of distros. My main take home is to never install NetworkManager or a resolvconf and to avoid systemd if at all possible, unless I absolutely know that I am going to need those state of the art DNS capabilities.

I have mostly managed to avoid resolv.conf issues since the default Gentoo image has a sane setup (even if using dhcp on a laptop and switching wifi and wired). However, every single time I have tried to set up a system using another distro something has gone wrong, and in support of the theory that NetworkManager is a major contributor to the problem the one Gentoo system with NetworkManager installed had the same issues.

To echo the plea in the original article, in nearly every case the primary challenge has been to figure out exactly what documentation actually applies to the system at hand because distros seem to change this completely out of sync with any attempt to correct or align the documentation.

I suspect that on an individual user level this leads to a happy path situation where everyone who does the right thing by accident is quiet and the ones who need something slightly different are never heard from because they weren't able to even connect to the internet (probably not quiet that bad).

tgbugs··on FreeBSD Core Team Statement on FreeBSD Development Processes
Here is a writeup that provides a good review of the context for this [0].

0. https://arstechnica.com/gadgets/2021/03/buffer-overruns-lice...

tgbugs··on Life's vast diversity defies easy definition
I've gotten it down to more or less one rule. Keep being. Everything else flows from that one rule, often with surprising consequences. Coelacanths are better at keeping being than mountains and continents.
tgbugs··on Excel Never Dies
In academic data management I have identified what I suspect is a common progression over the course of a career. Obliviousness to the problem. Rage at the inadequacy. Search for alternatives. Realization that you do not have the resources to build and maintain something else, much less train all the labs to use it. Further realization that it is harder to explain how to set the right file encoding and the fact that a csv file is not a colon separated file to hundreds of labs than to just accept xlsx. Acceptance that Excel is a more reasonable user interface for data deposition than anything you could come up with.

It is sad, but at the end of the day, however bad Excel is for life sciences data (to the point where standards bodies renamed genes due to autoformat issues!?), it ends up being better when usability and bad data edge cases are considered. Defaults matter for non-technical users, and even asking them to change the format they save in to csv is likely to cause issues because it is one more manual step that can go wrong, or there is some locale nonsense that will cause something to break etc.

tgbugs··on Piracy is not theft, Lost sales don't exist, says Minecraft creator (2011)
In my memory Gabe Newell was one of the first to articulate this point in the game dev community, however going back to check the dates, it seems that it was in October or November of 2011, suggesting that Notch may actually have kicked off this thread.
tgbugs··on Wikinews mourns loss of volunteer John Shutt
I am greatly saddened to hear this. I came to know about him through his work on fexprs (he was one of the world's leading experts on fexprs due to his work on Kernel). His insights on language design, his general willingness to share his own learning process, and his seemingly unquenchable curiosity will be missed. Of interest to those here might be his many posts on LtU [0].

0. http://lambda-the-ultimate.org/user/7549/track

tgbugs··on Show HN: Redbean – Single-file distributable web server
I looked into building SBCL using chibicc last weekend in the hope that one could build a truly portable lisp runtime using the ape toolchain (Yes, yes, I know you couldn't possibly pick two more different approaches to software portability). Turns out the GNUC extensions for __asm__ are the primary stumbling block (though I'm sure there are others). tcc supports the GNUC extensions needed, and chibicc supports the thread local storage needed for dynamic variables. Looking forward to future developments!
tgbugs··on The modern packager’s security nightmare
If developers are unwilling to maintain dependencies and be good citizens of the larger language community, should they be adding those dependencies in the first place?

If you're not operating in the large ecosystem then fine. But if your project is on e.g. pypi, then there is an issue.

(edit: Note, yes I know the virtualenvs exist, docker exists, etc. but those are space and complexity trade-offs made as a workaround for bad development practices)

tgbugs··on The modern packager’s security nightmare
The problem is actually far worse than that. While the gp has what seems to be a reasonable solution, the issue is that you can't actually know what distribution is going to package your software, or what environment it is going to run in. There are code bases out there that still work decades later without any active maintenance, but if you need maintenance just to be able to build software in a new environment something is wrong.

The underlying issue is that there are no standards for how to package software in a multi language environment. If I want to go from a state where (require 'module-name) fails to a state where (require 'module-name) succeeds, there are a potentially infinite number of ways that that could be accomplished, a single software project cannot ever specify all the possible ways for building software. What they can try to do use uniform interfaces and standard patterns for building their software, in a way that delegates dependency management to an external system. It seems that it is hard for software developers to admit that other people know more about how and where their software will be running than they do.

Good engineering practice seems to dictate that dependency and environment management should be completely orthogonal to the development of an individual component or individual functionality. The op is 3 stories about what happens when the two are not kept orthogonal. The fundamental problem is that it is often easier for individual projects to make decisions that conflate the individual project with its dependencies (no longer orthogonal).

To my knowledge, there is not a universal or well understood set of requirements that could be used to specify what a stable interface between an individual software project and its dependencies looks like. There are a number of candidates, such as gentoo ebuilds, rpm spec files, etc. however I have not seen one that effectively accommodates all of them. Further, there are languages where the implementation (or even design) makes it impossible to keep dependencies and individual projects orthogonal.

The end result of non-orthognal systems is more work for everyone, more wasted cpu cycles, and worse security. Distros can't stop people from using languages that conflate the two, but they can tell them that they are on their own, and that the distros can't depend on components written in such languages in the core of the OS. To everyone pushing the rewrite it in Rust meme this should be a wakeup call. The current design decisions in the language and limitations of the implementation make it less secure than C or C++ because swapping out dependencies is bottlenecked by the centralized primary development team, and maintainers and users can't take orthogonal action to fix an issue.

tgbugs··on The modern packager’s security nightmare
Robust for everyone. In theory it is the responsibility of the Clojure devs, but if there isn't a packaging workflow that they are aware of, how can they be expected to integrate with it and make design and development decisions that it would reveal to them? The point is more that, the greater variety of different environments a piece of software runs in the more likely it is that systematic weaknesses will be revealed, sort of like chaos engineering, except for whole environments instead of sporadic failures.
tgbugs··on The modern packager’s security nightmare
I think that there is a good reason to keep those projects in the main distribution: it makes them more robust and prevents the build systems and bootstrapping process from becoming a massive pile of technical debt.

For example, in order to get clojure 10 running on Gentoo I had to go dig through the git history to figure out where spec-alpha and core-specs-alpha and clojure itself did not form a circular dependency in maven. Because clojure was not being packaged in a variety of ways, they now are at risk of making maven central a hard dependency, which makes the whole project less robust.

tgbugs··on The modern packager’s security nightmare
I agree. The context was missing from my original, which is, "why can't you just use pip to install dependencies in production," which is effectively the answer that Michał once got from a PyPA maintainer when asking about setup.py install.
tgbugs··on The modern packager’s security nightmare
Fantastic article. I now have something to point people to when they ask "what is wrong with pinning?" or "what is wrong with static linking?" or "why can't you just use pip?" Michał has had to deal with some pretty crazy stuff the last couple of months ... scratch that, years.

The recent attempts to empower developers to distribute their own software means that there is now the potential for there to be as many bad security practices as there are pieces of software, because systematic security design that used to be managed by distributions has been pushed down to individual software projects, which have only a tiny view of the issues, and thus repeatedly make locally convenient decisions that are disastrous for everyone else. What do you mean someone is using a project other than ours that shares a dependency? Why would they do that?

One other thing to keep in mind is that from a security standpoint the approach that Nix takes is not good. Nix can deal with pinned dependencies on a per-package basis, but if those pinned versions are insecure and the developers don't have a processes for keeping dependencies up to date, then users are sitting ducks.

Unfortunately pinning is a symptom of at least three underlying issues. The first is that developers do not properly assess the costs of adding a dependency to a project both in terms of complexity, and in terms of maintenance burden. The second is that many of the dependent libraries make breaking changes without providing space for the old api and the new api to coexist at the same time for a certain period so that developers can transition over (I have been bitten by this with werkzeug and pint). Mutual exclusion of versions due to runtime failure is a nasty problem, and pinning hides that issue. Finally it seems that at least some developers are engaged in the Frog and Toad are Cofounders continuous integration story, but with a twist, rather than deleting failing tests, they pin packages so that they don't have to see the accumulating cost of pulling in additional dependencies. Externalities, externalities everywhere.

edit: because it is just too on point https://medium.com/frog-and-toad-are-cofounders/technical-de...

tgbugs··on The DreamBank, a collection of over 20k dream reports
When intensely focused on solving a problem, or following a day of uninterrupted implementation, I have had programming dreams that go on all night. The dream is nothing but the text of the code (usually highlighted with my custom theme) in a buffer that takes up the whole of my visual field in the dream. I have never been able to make out any particular details of the code, and it is not clear to me whether such dreams are at all productive since they don't get at the abstract level of the problem.
tgbugs··on WTF Python: Exploring and understanding Python through surprising snippets
This one is a bit more subtle. Assume there are two classes on that uses @property and one that does not.

    class Here:
        @property
        def booleanPredicate(self):
            return random_bool()


    class There:
        def anotherBooleanPredicate(self):
            return random_bool()
    
    here = Here()
    there = There()
What happens in the following cases?

    here.booleanPredicate           # as expected
    here.booleanPredicate()         # loud failure
    here.anotherBooleanPredicate    # silently always True
    here.anotherBooleanPredicate()  # as expected
So you might think that you should _always_ use @property for boolean predicates, except that there are libraries that use the anotherBooleanPredicate version so you are now at risk for silent always True behavior (creeping sanity destroying evil behavior). To prevent the silent failure you should always start by calling the predicate so that it can fail loudly. Worse if someone does a refactor and misses going from @property form to function form then the silent failure literally cannot be detected by running the program (!).
tgbugs··on WTF Python: Exploring and understanding Python through surprising snippets
True, but the problem is that in pursuit of that mantra the language has wound up disempowering engineers and has forced even more decisions about trade-offs onto them: do you want readability, performance, or maintainability? You usually can't have all of them because of some lurking performance tar pit.

An example here is the conflict between needing top level imports for sanity and static analysis (there was an instagram blog on this a while ago) while also wanting fast startup time. If you import requests at the top level then you cannot have fast startup time, so you wind up importing it outside the top level so that code paths that don't use requests don't have to pay the time cost of loading it, but then you have imports that aren't at the top level!

edit: oh, and don't even get me started on pkg_resources [0], which isn't just a tarpit, it is a full blown blackhole beartrap waiting for the unsuspecting.

0. https://github.com/pypa/setuptools/issues/510

tgbugs··on WTF Python: Exploring and understanding Python through surprising snippets
There are some that you can find in [0], but they are often de-contextualized (and sometimes aren't really Python's problem, because there was a trade off that had to be made, and the LOL is just frustration as a result of the bad ergonomics that it creates), those and some others will eventually go in an longer post when I finally get that set up.

To give one concrete example of an LOL PYTHON consider the @property decorator. While it seems like a really cool and handy idea that could let you save some typing in some cases, it is actually a trap that you should almost never use because when you inevitably discover that there is some parametrization that you need to pass to the ... attribute, you are suddenly faced with a massive refactoring. Also if you ever make the mistake of having boolean properties such as isDir or isUrl and somewhere else you have a predicate that is a function instead of a property then isFile will always return True when you meant isFile(). The only safe solution is to never use properties/attributes as predicates. These are nasty footguns that seem obscure and unlikely to affect you until you have the misfortune to already be in the briar patch.

0. https://github.com/search?q=%22LOL+PYTHON%22+user%3Atgbugs&t...

tgbugs··on WTF Python: Exploring and understanding Python through surprising snippets
While this repo is great for education, it doesn't cover the deep problems with Python that you only discover when you try to do something "unapproved" or slightly off the happy path. Depending on the domain you are working in you may never encounter such a situation, but if you do, be prepared to lose your sanity one omnipresent design flaw at a time.

Over the years I've been collecting a series of cases that are somewhat more nihilistic and depressing under the general category of LOL PYTHON. The little inconsistencies, the boilerplate that is required if you don't want to use only the approved, not performant, and breaks all sorts of other hidden assumptions so you can't actually use the code outside very narrow settings approach, eventually just evoke a nihilistic chuckle and a note to never start a new Python project again.

tgbugs··on Deep Nose may one day be the best diagnostician in medicine
If you haven't read "What the fly’s nose tells the fly’s brain" [0] take a look. It helps explain why the olfactory sensors might actually be selected to have wide spectrum sensitivity (it's a feature not a bug).

0. https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4522789/

tgbugs··on Creating Languages in Racket (2011)
I was sitting at that table during that conversation. I'm sorry to hear that Leondro's experience was not a good one, but he does not speak for everyone that was there, he may have felt uncomfortable but he cannot speak for the others.

To paint a whole community based on those interactions is completely unwarranted. There are political issues within the Racket community as there are within any community, but they are not the ones described here.

In point of fact, because of attitudes like the one expressed by the parent certain extremely valuable, active, and long standing members of the community have ceased to participate publicly because of abuse they have received by, shall we say, new incoming "waux" participants.

tgbugs··on Ontology of Psychiatric Conditions: Taxometrics
In his language he conflates the diagnostic code with the etiology. He tries to avoid this, but is missing the concept for etiology, so he winds up in a situation where he can't talk about the relationship between the diagnosis and what is really going on, because there is only the question of whether the diagnosis is "real." The answer is that yes, the diagnosis is always real, but it is not what we care about if we want to understand what is really going on. This is why I said he is on the right track. In his ADHD example he has nearly all the parts, diagnosis and symptoms, but is missing the free variable for the etiology. You can see this because if he had this concept then it would be clear that there is no cure for ADHD, it isn't even clear that it is a "problem" except in the context of modern civilization, and the etiology is a fundamental difference in the structure of the brain, not something you can "cure."
← PreviousPage 6 of 9Next →