HNHacker News
TopNewBestAskShowJobs

tgbugs

1,061 karma · joined April 11, 2019

submissionscomments
tgbugs··on Cryo–electron microscopy breaks the atomic resolution barrier
UP doesn't really apply here. The data the underlies the reconstructions requires massive averaging of individual objects as part of the tomography (see Radon transform for the core approach). In addition those objects/particles need to have the requisite symmetry/similarity/regularity in structure (not universally applicable), or the population of them needs to be completely homogeneous (hard to achieve). I suspect that there are now better techniques for detecting outliers so homogeneity might not be as important.
tgbugs··on Cryo–electron microscopy breaks the atomic resolution barrier
Some readers here might be interested in the history of the technology that has enabled cryo-EM. One of the key innovations was the development of CMOS direct detection devices that are able to detect electrons with extremely high signal to noise ratio, operating very close to the thermal limit of the DDD itself. I think it is an excellent example of the fundamental interdependence of cutting edge research and cutting edge engineering. Some (maybe most?) of the initial research and development [0, 1] on the cameras was done in my grandadvisor's lab. Another part of the story is related to the massive improvements in algorithms that in some cases have enabled nearly real time reconstruction and visualization of viruses from cryo-EM samples (I don't have links for these handy), and the work to increase the resolution of the reconstructions presented in the linked article.

0. https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2359769/ 1. https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3210420/

tgbugs··on Forearm artery reveals human evolution continues?
I work with a consortium that is trying to map the anatomy of the peripheral nervous system. My key take home has been that our knowledge of peripheral anatomy at population scale is woefully inadequate. People look at Vesalius and think "oh, that was settled 500 years ago," but as it turns out it seems that we know far more about the peripheral anatomy of our pets and domestic animals than we do about our own.
tgbugs··on Toward a “modern” Emacs
Glad to see that other observers have keyed in on the discoverability aspect. I tried to highlight it in [1]. Unfortunately I haven't been able to hop back into the discussion there, and things have been moving at a fantastic pace.

The longer I have been working to develop processes and systems, the more I have come to appreciate defaults that do not change. It is interesting to see some of the new *coin and blockchain folks in their dark forest threads worrying about what happens if the interpreter changes its semantics and lamenting that contracts are meaningless if the interpreter can change. That is what standards are for, and that is what the "backwards geezers" are trying to do for Emacs since it doesn't have a standard, only social norms. I'm not too too worried though, since there are many sensible people in the community who understand why changing defaults can destroy trust and waste the time of millions of people. I am also not worried because there are many creative solutions to the problem of how to attract and maintain new users in a way that they can come to appreciate the benefits of stability.

1. https://lists.gnu.org/archive/html/emacs-devel/2020-09/msg00...

tgbugs··on PEP – An open source PDF editor for Mac
This solves the namespacing problem and allows creators and consumers to use different names if they want. Searching based on the creator's original name for a project becomes a mess because there will be a very large number of HelloWorld applications out there. Interestingly enough the google web store sort of already does this. The issue that comes up fairly quickly though is how to deal with the relationships between different packaged and published versions of what is nomalinally the same code base, or even forks/branches of the same code base. Maintaining a verifiable and discoverable chain for published artifacts without completely confusing users or exposing them to various malicious attacks (change a single byte in the middle of that random string and you have a nice off-by-one attack). Lots of infrastructure would be required to pull this off, but it would be great if it could be built.
tgbugs··on Org-mode 9.4 is out. Can you help?
Technically it could be ported, but that port would require porting a major subset, if not all of emacs lisp as well. This is due to the fact that elisp closures are valid and often semantically critical arguments to src blocks. Defining the features that must be implemented to achieve a certain level of org-mode support and compatibility is something that definitely needs to be tackled in the future.
tgbugs··on Fennel – Lisp in Lua
I knew about Fennel, but did not know about Lumen. Thanks for the pointer!

edit: Looking at the git history is very educational for how to bootstrap a self hosting system like this. Fascinating.

tgbugs··on Neurophilosopher argues morality is rooted in brain science, not reason
Somehow I knew this was Patricia before opening the article (cbc.ca, neurophilosophy, and morality only have so many names associated with them). I had a number of discussions with her about this about two or three years ago, and my key take home from those is that you have to let go of what you personally think the term morality means when you enter into a scientific context. Moral behavior is not 'moral' in the absolute sense that is being rejected here, it is 'moral behavior' in the sense that it is what the average human being thinks society thinks the 'moral' behavior is in the given situation. The fact that, on average, there seems to be some agreement on this is fascinating. How such a thing evolves, and the reasons for its persistence are vital questions that we have to grapple with.

Another observation that I have had on this is that trying to convince philosophers that morality can be reduced to a decision problem and thus that Kant is not wrong, rather that he is just an asshole who didn't know that Turing complete systems exist, is a very hard thing to do. Their reaction against the dangers of belief in the categorical imperative is extremely well founded, and instructive for those who think that things like smart contracts might be a good idea.

One great advantage of defining traditional morality as being closely equivalent to the evolutionary imperatives of our biological substrate is that we can stop playing the stupid post-hoc rationalization game where we try to come up with rational explanations for what is fundamentally contingent behavior. This in turn provides us with an entirely clear space to start to imagine what post-moral society might look like, and envision what algorithmic morality might look like if we were actually able to feed Bentham's machine with all the factors instead of the stupidly limited number of measurements and dimensions that are usually imagined and that remain centuries out of date with the current state of the art in logic and computation.

Whether we want to live in a society where we have agreed that everything can be decided upon must be reducible to a decision problem, or whether we want to allow ourselves the get out of jail free card that is denying that we know enough to make the decision at all is another question. However, before we can even get there we need to be freed from the misbegotten idea that morality is in any way universal, or derived from natural law, or that natural law even exists. Out of an incredible body of work I will always thank Patricia for taking this head on.

I should also note that the argument that morality is rooted in biology is in no way mean to belittle what evolution has discovered. Patricia has argued that many of the positions taken by modern defenders of enlightenment ideals wildly undervalue so called traditional or local knowledge as "unenlightened" because that knowledge was not arrived at from first principles, but from long, hard experience accumulated and passed down over generations, and that westerns in particular have an abysmal track record when it comes to thinking they know better and thus not listening to the people who know that the reason why the crops are not planted by the river is because the hippos will come out and try to kill you if you do.

tgbugs··on Filecoin: Proof of Storage Systems
Thanks for the pointer to Gwern's writeup of timestamping. I have mentioned the idea on a number of occasions as a reasonable way to guard against investigator misconduct around tampering with data files and now have an excellent review article to point to!
tgbugs··on Bump Emacs Version to 27.1
No. It is in the 28 tree.
tgbugs··on Twitter hack has profound national security implications
This kind of scenario is exactly why I imagined that the very first thing that the secret service would do is snap Trump's phone in half and throw it in the bin. Yet another thing to add to the long list of new legislation that needs to be written, though I'm not sure how it do it. "All government officials using twitter must also post the PGP signature of any tweets they plan to make BEFORE they post them to twitter, and also post them to _some other service_ as well."
tgbugs··on Programming at the REPL (2018)
Here is a question that I have about Clojure and its REPL. I have tried 3 times over a period of a year or so to get it to behave like a common lisp REPL and every single time I have hit a brick wall called project.clj and/or deps.edn (which open a terrifying black hole to maven). My simplest use case is to be able to call `(expt 2 10)` from a bare clojure install without leaving the repl. As far as I can tell it is impossible to achieve this. I finally gave up and wrote a gentoo ebuild to install the numeric tower just to see if it was possible [0]. What I learned was that I have no idea how clojure libraries interact with the JVM. `pomegranate` gets the closest but I'm still fairly certain that you can't install that from a repl without resorting to hackery [1]. I think I understand the tradeoff toward using project.clj and deps.edn to create sane and static environments for a project, but the friction is larger than nearly any other language that I have tried because you are practically forced to create a project structure in order to do anything.

0. https://github.com/tgbugs/tgbugs-overlay/blob/master/dev-jav... 1. https://github.com/clj-commons/pomegranate

tgbugs··on Google Common Lisp style guide
Many times when working with code that uses structs in Racket I have found myself fruitlessly grepping for the definition of some mysterious and troublesome function before eventually remembering to check whether there is a struct named foo with a member named bar somewhere. Normally this is not a problem so long as the file can make it far enough through the syntax phase that you can resolve the names. Yet somehow when the code is well and truly broken then somewhere, somehow, a struct will be involved without any way to resolve the member name. I say this having written my own symbol creating and binding macros before I realized the pitfalls and now dread having to go back and fix it. It seems like such a cool idea in principle.
tgbugs··on Worrying about the NPM Ecosystem
Gentoo prefix can run on a wide variety of operating systems and distributions. It needs a few updates to work around the recent changes in macos permissioning, but if it can find a familiar shell it will more or less work as expected.

I think part of the above comment is expressing frustration about the fact that part of the reason for the lack of wide portability of these programs is precisely because people say "oh they can't do x" or "this is operating system specific" and taking it as axiomatic rather than realizing that with a bit of engineering time and effort they can be extended to work on other systems. This especially since there is pretty much no language that is used entirely by itself without dependencies on another at some point in time. If your language has a ffi, then you need a real package manager to accompany it.

[0] https://wiki.gentoo.org/wiki/Project:Prefix

tgbugs··on Worrying about the NPM Ecosystem
The solution mentioned at the start of the article is what distribution package maintainers have been doing for decades. I would take this account as a giant flashing warning sign of what could happen to the flatpak/snap ecosystem, and also a flashing warning sign for languages that are developing their own package manager, especially if it is difficult for packages from the language package manager to be integrated into actual system level package managers. The curation effort required to get NPM into manageable shape is almost certainly beyond the scope of any traditional community effort.
tgbugs··on Life is 90% of my use cases for org-mode
org-sync [0] is all that I could find when I went to look into this last week. It does not have all the functionality that I would want (e.g. comments should be begin_src markdown blocks), but could serve as a start for something more, and it might meet your needs as is.

0. https://github.com/arbox/org-sync

tgbugs··on Life is 90% of my use cases for org-mode
An anecdote on what you might be missing. There is nothing concrete that not using org-mode would cause you to miss out on, it is rather the possibility of being able to access one of countless workflows that have been built on top of it.

When I started to use org-mode it was because I needed to generate a gant chart and I wanted a text format. I haven't used that functionality every again. Since then I have used org-mode for a variety of things, but never all at once, always a little piece at a time. Typeset a thesis in latex? Execute analysis code in a reproducible way? Write DRY bash scripts and tangle (compile) them? Run and log the output of one-off commands on remote servers so that if you ever have to do it again you have a record of it? The list goes on and on.

Last week I was told that I needed to start keeping track of the time I spend working on different tasks. Despite keeping todo lists I have never used the org clocking functions, ye there they were there, just a C-c C-x C-i and C-c C-x C-o away. Integrated into my workflow when I needed it with all of 30 seconds of effort and two key combinations of overhead.

Emacs is useful because countless others have encountered problems the likes of which a single person only rarely dreams. Not only that but they have probably already implemented a solution that is fairly easy to find once you encounter the problem and in 80% of the cases can be used unmodified.

Yes, you and all the rest of us are missing something. It is impossible NOT to miss something and no tool can solve that for you. The question to me is whether you want to spend your time learning a tool and integrating with an ecosystem where you never have the possibility of benefiting from the things that others did not miss.

tgbugs··on Life is 90% of my use cases for org-mode
Honestly at this point it is usually easier for me to read the raw org-mode source file in an emacs buffer than to wade through whatever random web rendering and author has picked when they export to html.
tgbugs··on Life is 90% of my use cases for org-mode
While I might have been concerned about this at one point in time, emacs and gcc are some of the most ported pieces of software in existence. That said, there have been some discussions about trying to work toward a specification for how things like org-babel should work so that other platforms can replicate the behavior inside of emacs. However, as others have stated elsewhere in the comments, once you accept emacs into your life there isn't really much incentive to spend time standardizing interfaces for things that can be handled more informally and as needed by the users. As a result those efforts need some internal incentive (like better or clearer documentation) to have development time allocated to them.
tgbugs··on Hypothes.is: An Open Annotations Platform
No, we retain a local copy of the annotations, but that's about it. Last time I checked the hypothes.is client didn't have the ability to use an arbitrary backend. We did at one point create a fork of the web extension that could point to an arbitrary backend but the maintenance overhead ended up not being worth it.
tgbugs··on Hypothes.is: An Open Annotations Platform
My PhD work would not have been possible without Hypothes.is. My group uses it for a variety of information extraction and curation tasks, and I'm fairly certain that one of my colleagues has the highest number of human made annotations in the system (though in private groups).

Hypothes.is is great for prototyping curation workflows to explore what is possible before spending time implementing yet another tool. It also hits the sweet spot for having a UI that is just accessible enough for non-technical users that can display annotations made by bots. We have been using hypothes.is as the backend to crawl [0] research resource identifiers from the scientific literature for 4 years, and it has been solid the whole time.

I see some questions/concerns about the w3c compliance of the API. I'm pretty sure that there is just a switch the needs to be flipped, and that it has been implemented. Yep, it has [1]. Also as others have suggested it is fairly straight forward to set up your own annotation store, though it is not simple to replicate the Hypothes.is setup.

I hope that the pivot to education continues to go well so that it can fund the infrastructure, because Hypothes.is provides a very valuable (if hard to capture the value of) service.

0. https://github.com/SciCrunch/scibot 1. https://github.com/hypothesis/h/blob/master/h/presenters/ann...

tgbugs··on Design Principles Behind Smalltalk (1981)
Work on this has been done. See Polymorphic Identifiers: Uniform Resource Access in Objective-Smalltalk [1].

1. https://www.hpi.uni-potsdam.de/hirschfeld/publications/media...

tgbugs··on Coming to Chrome: a new way to use tabs
I agree that the feeling is quite freeing, and very effective for sandboxing activities to prevent distraction, the only trade off is when I have run a garbage collection workflow to reclaim space (usually completely adhoc). In fact writing this now, it seems to me that it almost completely removes the need for careful and deliberate use of the interface, you can do what you want nearly at the speed of thought because the mechanics don't get in your way. The trick is that you have to engineer the action space that you are in to prevent certain kinds of thoughts such as "I wonder if I have new email" from expressing themselves as finger presses. (Side note: this makes me think that there are going to be some really hard to solve problems when someone finally gets the brain computer interface hardware working, because determining what thoughts to transform into actions and what thoughts should just remain thoughts is a fundamental problem for the brain itself.)

Rearrangement of the contents of virtual desktops and the desktops themselves is a topic in and of itself. The emacs world has a lot of tooling around this as well (see for example [0]), and the are a number of patterns/workflows for managing/composing/recombining workspaces that would surely translate other window managers since they deal with essentially the same issues.

For me the issue tends to be that it is easier and faster to create a new window of whatever kind wherever I am to answer the immediate need than to find the right one to answer it in, so I just open a new terminal window, jump to where I need to be, do what I need to do, and then ... forget to close it. Similar issue with dragging a browser window around with me wherever I go. One answer to this might be to slightly modify the behavior of the "open new instance of this program" key to act instead as "jump to most recent instance of this program, or if it does not exist, create it and jump to it."

One thing related to gc is that I started to work on but did not manage to complete, was the ability to snapshot the layout of all windows across all desktops in an x session. That would allow effective patterns to persist across restarts without the need to come up with a way to specify how things should be arranged. It would allow them to be arranged by whatever means, saved, and restored. I'll probably get back to it at some point.

As a note, anyone with the inclination can do this kind of thing in any language as long as it has xlib bindings.

0. https://www.youtube.com/watch?v=rjOhJMbA-q0

tgbugs··on Coming to Chrome: a new way to use tabs
In principle yes. The problem is that they loose their topicness and quickly become "oh this was the closest virtual desktops to where you were in the grid with an empty space." This is largely because I made the mistake of originally implementing the transition system as a grid (this was 5 years ago or so). Since then I realized that I basically want a button that will let me create a new topic space, and then remove that space automatically when I close the last window in it. Figuring out how gc stale topics (I can recreate them from memory) and/or discover which topics already have spaces is the hard part (I have had the ability to display topics on desktops via conky for years and that doesn't seem to have helped).

I have also thought about trying to decouple how spaces are associated per monitor, but couldn't figure out a way to interact with such a system that wouldn't leave my brain lost somewhere in even higher dimensional virtual spaces than it already is!

tgbugs··on Coming to Chrome: a new way to use tabs
Man, I know I have a problem, and I thought it was bad at about 700 tabs across 25 windows (virtual desktops are enablers for the window count). But seeing this thread I clearly need to up my game/download more memory.
tgbugs··on Making Emacs Popular Again
I think what you're looking for is TRAMP [0,1]. After resisting it and continuing to ssh into remote hosts in a shell, I finally started to switch my workflows over, and the improvement is substantial. Async remote compiling might work out of the box in some cases, or it might require some additional configuration.

0. https://www.gnu.org/software/tramp/ 1. https://www.emacswiki.org/emacs/TrampMode

tgbugs··on Bringing GNU Emacs to native code [video]
I don't think that is how libgccjit is being used in this project. Emacs is not being linked with libgccjit. libgccjit is only being use for AOT compilation.
tgbugs··on Bringing GNU Emacs to native code [video]
I have a Gentoo ebuild [0] almost working for this (I think I'm missing the step where the eln files are loaded before dumping the base image). The compile times are ... substantial. However they don't affect the development process for new code since the interpreter is always there, and I am excited to see what performance gains we will see.

From an engineering perspective this is a excellent example of a direct path from interpreted to compiled code. The trade-offs are clear (heck, they are number 0-3), and while there is complexity, all the engineering time has been effectively concentrated inside a single project, rather than forced upon tens of thousands of maintainers and users. Bravo. I wonder what other bytecode interpreters could benefit from this toolchain. Compile times from qlop.

On a Intel(R) Core(TM) i7-4770K CPU @ 3.50GHz Without comp `2020-05-03T15:33:27 >>> app-editors/emacs: 6′40″` With compile `2020-05-03T18:35:43 >>> app-editors/emacs: 2:11:45`

0. https://github.com/tgbugs/tgbugs-overlay/blob/master/app-edi...

tgbugs··on Operating Systems Without Systemd
I didn't mean to imply that Nix itself did not, rather that when I have seen Nix mentioned in other contexts where I might have expected to see Gentoo mentioned as well, it was not. The thesis probably isn't the best thing to link because it was written before both ecosystems evolved into what they are today, e.g. at least one statement in the thesis about Gentoo is no longer true (Gentoo prefix allows regular users to install and manage packages using portage on a variety of systems [0]).

0. https://gitweb.gentoo.org/repo/proj/prefix.git/plain/scripts...

tgbugs··on Operating Systems Without Systemd
Life long Gentoo user here. The fact that NixOS other other new fangled package management systems are rarely mentioned in the same context as Gentoo has led me to wonder whether the new kids on the block have done their homework.

I realize that Gentoo became a meme at some point, but it also seems that it might have transcended to the level of infrastructure. Thus, you rarely ever heard about it for the same reason you don't hear people talk about hammers -- it is doing its job running tens (hundreds?) of millions of chrome books among other things.

No flare, nothing fancy, it has solved a whole bunch of packaging, deployment, and environment control problems and gotten out of the way of its users (mostly ... chuckle), and it did it all with a pile of bash scripts and a little python here and there. Want to use systemd because you have a use case that would benefit from it? Go right ahead! The engineering work is done, no need for fights on the mailing list. Don't want to use systemd? `eudev` to the rescue! There are sound engineering reasons for not using systemd while also wanting to use some other (seemingly) completely unrelated piece of software that just happens to have a dependency on the kitchen sink.

Despite being a rolling release distribution, I find that the UX and workflows are more stable over long periods of time than any of the more popular LTS style distros. When I started fiddling with Ubuntu so that I could help my colleagues debug issues it took me an embarrassingly long time to realize that there isn't really such a thing as Ubuntu, just 14.04, 16.04, 18.04, etc. Each is some different form the other that stack overflow questions from one LTS are often simply wrong for another.

Writing this I wonder whether rolling release distros aren't effectively the original form of chaos engineering -- if everything is going to be changing all the time then it forces the developers to solve a different and perhaps more fundamental set of problems and ultimately leads to greater stability in the long run.

← PreviousPage 8 of 9Next →