I'm in Sweden. I want to go back to the old ways. I hate how much the US controls our daily life. I hate loss of privacy and the presumption that everyone has a Google or Apple account, and are subject to their whims with little real alternative.
So I stopped using BankID over two years ago, and do most of my daily life in cash.
BankID is made by our banks but okay, I get the phone part.
How do you function day to day without BankID?
It is so integrated now """for convenience""" but yea it really is crazy. Especially how it is tied to having a bank account but the login is for everything. Payments, insurance etc...
Also how it needs Google play so Huawei phones got banned.
I function by being stubborn, and having a wife who can help with a few things.
If BankID worked on a free OS then that would be nice for a few things (like paying taxes, which I still do on paper), but other things are both BankID and Apple/Google smartsphone.
For example, I've made it very clear to my kids' school that I do not and will not get a smartphone, so I cannot use their app (based on Google Classroom). It took months, but now they send me the weekly newsletter by email, and I can call to say if the kids are sick. While my wife can handle the scheduling changes for fritids.
I also have the advantage of living in the center of town, a block from the centralized government services office. The queue is very short most of the time. I also live above my bank, though I'm thinking of switching to Handelsbanken, which is about two blocks, since I've seen how Swedbank is deskilling their local branches.
For the bank I still use a bank dosa. For bus travel I use kontoladdning, though the local transit system wants to replace that with a dependency on (US-based) bank cards - something I think is bad for the unbanked (including youths), visitors from certain countries, and bad for Swedish security as it lets the US restrict someone's ability to use mass transit. For health care I call the local medical center.
I work for myself, through my own aktiebolag, and my accountant handles most of the bookkeeping side of things. My customers are all outside of Sweden, so they don't care about BankID.
A few years ago it was hard to explain to people why I didn't use US-based systems. Over the last couple of years it's become a lot easier, for obvious reasons.
There are still enough old people and others that at least essential services don't require BankID. My wife worked with Ukrainian refugees who had a work permit but couldn't get a bank account. The hotel paid their salaries in cash. That's several levels harder than I have to deal with.
You'll be surprised at how many places still take cash, or will do a faktura, or accept simple bank transfer like we all did 20 years ago.
They show a number of ways to encode values, such as a 5-hole triangle code, where the "O" in the following indicates a hole:
O O O O O
9 5 2 0
8 4 1
7 3
6
To encode the value "8", notch out the holes (indicated with "U") which cross to 8 (indicated with "\" and "/"), like this:
U O U O O
\9 5/ 2 0
\8/ 4 1
7 3
6
This lets you encode 10-digit values with 5 holes and two needles -- remember, inserting the needles takes time. (And there were all sorts of devices made to minimize that time.)
There were also extensions of these to handle names, used to search small (< ~10,000) literature collections, and more.
The most mathematically sophisticated is likely Zatocoding, a superimposed coding method related to Bloom filters.
The Bourne book goes into these variations in detail.
You should take a look at the Bourne book, if you can get hold of a copy. It's an amazing book which draws on the generation or more experience in working with mechanical systems, and the first generation experience in using digital methods. Here's what it says about the code you mentioned, compared to the triangle code.
"From a space standpoint, one of the most efficient and most commonly used schemes is the 7-4-2—1 code, which only requires four holes to represent any number between 0 and 14 (Fig. 5-6f). Normally the four holes are only used to represent the digits 0 to 9, with zero represented by an unnotched code field. This introduces some ambiguity since a field with no punches in it may represent either missing data or a zero digit. The 1 hole will be punched every time that the numbers 1, 3, 5, or 8 are punched. If there was a need to search the file to select the cards which were punched with a 1, then a single needle pass in the 1 hole would also drop out all the cards which were punched with a 3, 5, or 8. Similarly, a single needle pass in the 4 hole would also select the cards notched with 5’s and 6’s. For this reason, this particular code does not lend itself to rapid selective searches. However, it is extremely useful for applications that require sorting cards into sequence."
"Several other coding schemes that also permit relatively rapid serial sorting are available. These schemes, at the cost of using more code positions than the 7-4—2—1 code, incorporate a triangular display on the card in order to simplify the punching and recognition by the user (Fig. 5—6k, l). Two holes are punched for every digit. The positions to be punched are the ones whose guidelines intersect at the desired digit on the printed display. Serial sorting is performed in the same manner as for the 7—4—2-1 code except that one more hole must be needled. One efficient triangular display scheme uses four code positions with a double-row card (Fig. 5-6m)."
I got really into edge-notched cards about 10 years ago. I made my own cards for handling chemical data. You can see them at 43:41 of my talk at https://youtu.be/y6dUkCxlrd8 . I also visited the Calvin Mooers archive at UMN because of his work in Zatocoding, Chemical Zatocoding, connection tables, and substructure search (Zatopleg). He mostly published as white papers from his own company, which makes it hard to find copies anywhere else.
Being a father and raising good kids is an invaluable role in society.
As an immigrant in Sweden, I love that I had so much paid parental leave to be with my babies.
In the US, where I used to live, parental leave is a joke. There are generations of people brainwashed to believe fathers aren't involved in taking children to the park, changing diapers, and so on, and brainwashed to think that seeing single men in children's spaces is abnormal and suspicious.
I don't see what can be more empowering than letting both parents have time with the new life they brought into the world, and working together to watch the child grow up.
What career is going to give that level of satisfaction to men?
After the Butlerian Jihad, my backup plan is to work at the preschool.
My sister thought to be a stay-at-home mother until the kids started kindergarten, then changed her mind after a few years as she found it so frustrating and tedious. My wife and I looked forward to when our kids started preschool, so I could do work and she could take classes. Neither of us are defined by having kids.
There's a reason Valium was "Mother’s Little Helper" in the trad-wife home of the 1960s!
The effort to fact check with LLMs is also high. Here's one from a few days ago.
Someone used AI to generate an image in the style of a Charles Schulz Peanuts cartoon.
Someone else observed that there were 5 fingers on the characters, and quoted as Google AI as saying “Charlie Brown, along with other Peanuts characters, is generally depicted with four fingers on each hand (three fingers and one thumb) ...”
Fact checking this with human sources is easy and not ambiguous. While LLMs are being trained that many cartoon characters only have a thumb and three fingers - it is a trope for a reason - so isn't it logical for LLMs to give the wrong answer for a comic where the human characters are actually drawn with 5 fingers?
My experience with LLMs is they keep getting things wrong, when details matter.
Do you ask the LLM to fact check everything? (In which case, why isn't that part of the standard prompt?) Or do you only ask to fact check things where you are unsure about the answer? (In which case, is it the algorithm telling you what you want to hear?) When do you stop the fact checking?
Exactly the same calculus as fact checking anything else from any other source. What are the social/economic/ethical consequences to me if the answer is wrong or inaccurate or incomplete? How much time do I have to check? How thorough should I be?
I imagine this calculus isn't really that different for most people. Or is it?
As for your example, I believe it. But I also feel it's a rather outlier example involving image comprehension of an obscure factoid. That isn't typical of how I use LLMs which is mostly as text-based question answering engines and not what I had in mind when writing the comment.
I guess LLMs for image comprehension need a much higher level of skepticism.
Well, in my case going to a Peanuts comic and looking at hands was pretty easy, and didn't involve any questions about negative environment or labor consequences, the massive hammering of web sites to gather data, centralization of power, and the like.
Like, "!w Peanuts" in my search bar, look at the image, and count fingers.
"a rather outlier example"
You wrote that you use AI to find "obscure connections" - aren't those all by definition outliers?
"mostly as text-based question"
I just now asked Google AI "how many fingers are on charlie brown's hand?"
It replied "In the Peanuts comic strip, Charlie Brown and the rest of the gang are traditionally drawn with four fingers (or three fingers and a thumb) on each hand."
No image comprehension, exactly as you had in mind. And completely false.
HN isn't showing me a reply option for your latest comment, so I'll reply here instead.
Just to clarify, I used plain Google search not Google AI mode. And opened search results which seemed "reputable," without knowing anything much about Peanuts cartoon or cartooning.
I had no idea at all about archive.org having it and didn't see it listed in the first two pages of search results.
I still find it confusing, especially given what the Variety.com link says which doesn't mention orientation. If the acceptable explanation for 4 vs 5 is orientation, why is it wrong when the AI generated 4 fingers? Does it not match the rest of the orientation?
Anyway, I'm not sure where this leaves LLMs. I'll explore image capabilities when I get some opportunity and keep your comment in mind.
The comment about using Google was more a curiosity. I hadn't seen the Variety link until yesterday, when I went to Google to reproduce the answer to verify it was from a text query, not an image query. Both Google AI and one of the top answers included that Variety link. When you mentioned it again, it strongly suggested you were using Google as your primary search method.
I think the right way to interpret the Variety link is that it's a single paragraph about trying to capture the feel of the comic using 3D software. As you saw from Charlie Brown holding a baseball, Shulz didn't go for a realistic look, but still conveys the sense of grasping. Modeling all five fingers all the time would not give the movie the right feel.
I wonder now if Google AI incorporates text from the top results into its answer.
"why is it wrong when the AI generated 4 fingers?"
The original discussion was when person X used AI to generate a image "in the style f Charles Shulz" where the Peanuts characters had 5 fingers, then person Y noted the use of 5 fingers instead of the 4 which is common in comics and cartoon, and quoted Google AI as saying Peanuts was traditionally drawn with 4 fingers.
I yesterday verified that Google AI would generate the same wrong answer with a text query, so it was not an image interpretation issue.
FWIW, after looking at a few hundred Peanuts cartoons, I can confidently say the AI generated image was not in the style of Schulz. The generated fingers were too realistic, and the background too complicated and detailed. :)
This for me is another example of why using primary sources should be the first thing to consider when fact checking - not LLMs (my experience is they are horrible at details), and not secondary sources (which have their own biases).
Not everything has easily-accessed primary sources, but many do. I think it's all too easy to fall into the trap of accepting the LLM answer because it feels right and is easy to generate. At https://freethoughtblogs.com/stderr/2025/01/18/ai-art-just-r... you'll see someone asked about which river Marbot swam across to spy on the enemy camp. It replied "Elbe". Then I did a text search of an English translation of the book and found he used a boat to cross the Danube to spy on the enemy camp, and he swam into freezing waters to save an enemy soldier.
Again, do you ask the LLM to fact check itself every single time? If that's useful, why isn't it built into the prompt? Or, if you are supposed to double-check the LLM yourself, why would you consult a secondary source if the primary source is so easy to find and search? And in that case, why not just use the primary source?
Further, if you aren't in the habit of checking primary sources then you won't have the experience to know how to find and check primary sources.
Even as a human, I find whatever sources Google shows to be inconsistent. I can't give any confident answer about the number of fingers. I think the answer is actually "4 sometimes and 5 other times."
So I'm not sure how much LLMs can handle this kind of inconsistency between "reputable" visual sources and text sources, nor how representative this example is.
> “The rig would automatically move the features around so it would match the way Charles Schulz drew the character,” Heller says....In some drawings, Charlie Brown has just three fingers, while in others, he has five
Anyway this wasn't the type of obscure connections I was referring to though I can understand you interpreting it that way.
Personally I think this example supports what I said about "reputable sources." They can't be blindly trusted either because they may be inconsistent with each other and which one we choose to believe (Reddit.com or TVTropes.com or Variety.com) becomes entirely subjective.
Your first link was cited in the 2nd half of Google AI's answer, and one of the top Google answers, so I think you are using Google as your information source.
The large majority of the images you link to show kids with 5 fingers, as well as 5-fingered baseball gloves. The cases of four fingers are due to orientation.
Your "1." also shows Marcie with five fingers. You see Charlie Brown with 4 fingers because he's holding a baseball. In 2. he's also holding a baseball. You would not see 5 fingers on one side because doing so would look strange.
In your unlabeled "0." there are plenty of kids with 5 fingers. There are some with fewer, but they are holding things or drawn in way to suggest we are seeing the hand from the side.
I don't understand your hesitancy. Your own samples should be enough for you to decisively conclude that the Google AI's claim that Peanuts was "traditionally drawn with four fingers (or three fingers and a thumb) on each hand" is wrong. If not, it sure seems like you trust Google AI over your own eyes. Why are you so hesitant to agree?
My point is that you don't need to consult secondary sources when the primary sources are easily available.
When this came up a few days ago, I spot checked the complete works of Peanuts, from a collection on archive.org at https://archive.org/details/peanutscomics19502000/Volume%201... . The consistent pattern across the nearly 50 years of Peanuts is the kids have five fingers unless obscured by orientation or objects.
You can do that yourself, and triple-check that Google AI's answer is clearly wrong.
Thus, I think it's a good example of how fact checking with LLMs can lead people astray, and the large negative externalities I mentioned combined with its well-known tendencies to make incorrect statements make it a very poor starting point when the primary source, at least in this case, is so easy to access.
If most of the sources are wrong, and LLMs are being trained on those, isn't it logical that the latter will also likely output that same wrong information?
When do you know if most of the sources are wrong, unless you yourself know most of the sources are wrong?
and "matching PyMOL's cSS* flags from Selector.cpp"
While the Rust code is cleaned up and easier to read, I can see that it preserves similar data flow, uses similar variable names, and of course identical constants.
For example, this is PyMol layer3/Selector.cpp:
/* look for antiparallel beta sheet ladders (single or double)
...
*/
if((r + 1)->real && (r + 2)->real) {
for(b = 0; b < r->n_acc; b++) { /* iterate through acceptors */
r2 = (res + r->acc[b]) - 2; /* go back 2 */
if(r2->real) {
for(c = 0; c < r2->n_acc; c++) {
if(r2->acc[c] == a + 2) { /* found a ladder */
(r)->flags |= cSSAntiStrandSingleHB;
(r + 1)->flags |= cSSAntiStrandSkip;
(r + 2)->flags |= cSSAntiStrandSingleHB;
(r2)->flags |= cSSAntiStrandSingleHB;
(r2 + 1)->flags |= cSSAntiStrandSkip;
(r2 + 2)->flags |= cSSAntiStrandSingleHB;
/* printf("anti ladder %s %s to %s %s\n",
r->obj->AtomInfo[I->Table[r->ca].atom].resi,
r->obj->AtomInfo[I->Table[(r+2)->ca].atom].resi,
r2->obj->AtomInfo[I->Table[r2->ca].atom].resi,
r2->obj->AtomInfo[I->Table[(r2+2)->ca].atom].resi); */
}
}
}
}
and this is pymol-rs's pymol-mol/src/dss.rs
// Antiparallel ladder: i accepts j, (j-2) accepts (i+2)
if a + 2 < n_res && res[a + 1].real && res[a + 2].real {
for &acc_j in &acc_list {
if acc_j < 2 || !res[acc_j].real {
continue;
}
let j_minus_2 = acc_j - 2;
if !res[j_minus_2].real {
continue;
}
let acc_jm2_list: Vec<usize> = res[j_minus_2].acc.clone();
for &acc_k in &acc_jm2_list {
if acc_k == a + 2 {
res[a].flags |= SsFlags::ANTI_STRAND_SINGLE_HB;
res[a + 1].flags |= SsFlags::ANTI_STRAND_SKIP;
res[a + 2].flags |= SsFlags::ANTI_STRAND_SINGLE_HB;
res[j_minus_2].flags |= SsFlags::ANTI_STRAND_SINGLE_HB;
if acc_j >= j_minus_2 + 2 {
res[j_minus_2 + 1].flags |= SsFlags::ANTI_STRAND_SKIP;
}
res[acc_j].flags |= SsFlags::ANTI_STRAND_SINGLE_HB;
}
}
}
}
That's close enough that I really think you should include the PyMol license info, before Schrödinger's lawyers notice.
Over the last few days I have learned that using code generation tools are increasingly used to create a "clean room" version of a product, using a definition which is far from its standard use.
I believe your use of "clean room" is another example of misusing the term.
Could you clarify how it was developed? Who had access to the original source code? Were code generation tools used, and if so, how? Was the PyMol source part of the training set for those tools? How did you ensure no copyright violations?
Warren was a friend of mine, and a passionate believer in open source software. He wanted people to be able to modify PyMol for their own purposes, and asked only for a license acknowledgment. Schrodinger, to their great credit, continues to honor Warren by maintaining the Open-Source PyMOL product.
If this project was not developed under true clean room practices, I ask that you continue to honor his work by including the PyMol license in your Rust rewrite.
If it was true clean room development, why does ./crates/pymol-algos/src/align/ce.rs say "This is a faithful port of PyMOL's `ccealignmodule.cpp`.", with comments like "Equivalent to PyMOL's `calcS`" and references to the original code in comments, like: "PyMOL: for (row = 0; row < wSize - 2; row++)"?
Dear Andrew, first of all — thank you so much for your feedback, both the technical and the legal parts. Your earlier comments about SDF and PDB parsing corner cases are incredibly valuable.
PyMOL has been one of my primary tools for 15 years, and I've always held it in deep respect. This project was born entirely out of a desire to contribute something to molecular visualization in the modern world — something fast, modular, and with qualities I've been missing in existing tools. And as a source of inspiration, I took the best one: PyMOL.
Of course I spent a lot of time reading and studying its code, and I openly took concepts and algorithms from it. I don't hide that — it's why the project carries the name it does, and it's why the README has had an Acknowledgments section since the very first commit: "Inspired by PyMOL, created by Warren Lyford DeLano. This is an independent reimplementation, not affiliated with Schrödinger, Inc."
You are absolutely right about the "clean-room" wording — I used it loosely, meaning "rewritten from scratch in a different language with a different architecture," not in the legal sense. That was misleading, and I've already removed it from the README.
You're also right that DSS or CE was a fairly direct port of PyMOL's algorithm, and it should carry proper attribution. At the same time, many other parts — surface generation, cartoon rendering, the shading pipeline — are done quite differently, and the gap keeps growing. But that doesn't excuse insufficient attribution where code was closely followed.
Going forward, I'm focusing on genuinely new functionality — Rust plugin system, web interface, novel shading models (try set shading_mode, skripkin!) — things the original PyMOL never had. But this is not an attempt to distance the project from DeLano's creation. It's a respectful continuation of his ideas in a completely new product.
Thank you again — your comments are making this project better.
You might mention in other forums, like the RDKit mailing list (though that's almost moribund).
I looked at the SDF reader, since that's what I know best. I see a few things which look like they need revisiting.
Line 75 has 'if name == "$$$$" {return self.parse_molecule();}' This isn't correct. This means the record name is "$$$$" (if you are RDKit), or it means the record is in the wrong format (if you are the CTFile specification, which explicitly prohibits that).
Also, does Rust have tail recursion? If not, the recursive nature of the code makes me think parsing a file containing 1 million lines of the form "$$$$\n" would likely blow the stack.
In principle the version number test for V2000 or V3000 should look at the specific column numbers, and not presence somewhere in the line. Someone like me might place a "V3000" in the obsolete fields, with a "V2000" in the correct vvvvvv field. ;)
The "Skip to end of molecule" code will break on real-world datasets. One classic problem is a company which used "$", "$$", "$$$" and "$$$$" to indicate cost, stored as tag data like:
> <price>
$$$$
$$$$
where the first "$$$$" is part of the data item, and the second "$$$$" is the end of the SD record. This ended up causing a problem when an SDF reader somewhere in their system didn't parse data items correctly. (Another common failure in data item parsing is to ignore the requirement for a newline after the data item.)
Please don't let these comments get you down! These details are hard to get, and not obvious. It took me years to learn the rare corner cases.
I also haven't done molviz since the 1990s, or used PyMol (I was VMD person), so can't say anything about the overall project. We started with GL, and had to port to OpenGL. :)
PS. A bit of history for you. PyMol's and VMD's selection syntax look similar because both drew on the syntax in Axel Brunger's X-PLOR. Warren DeLano came out of Brunger's lab, and VMD was from Schulten's group, which were X-PLOR users. (Schulten was Brunger's PhD advisor.)
Will you be adding support for using duplicate CONECT records to store bond type information? That's a RasMol extension that PyMol supports. You'll also need to support the pdb_conect_nodup option in the writer.
I see you interpret atom/hetatm serial numbers as an integer. Will you be using the base-36 or hybrid-36 variants (see https://cci.lbl.gov/hybrid_36/) which is a common way to handle more than 100,000 atoms?
Again, these are corner cases which come with experience. I've no expectation that a new program would handle them. I want you to know about them since they will be issues if you expect long-term uptake.
Some background. Calvin Mooers developed TRAC - the programming language - in the 1960s for "duffers", that is, people who were not computer scientists.
(A phrase he used in the writing of the time was "duffers", though I don't know if he specifically applied it to TRAC users.)
It was the first homoiconic language. There were a group of teens interested in programming that hung out with Mooers. One of these was L Peter Deutsch, who at 18 (and a year after writing LISP 1.5 for the PDP-1) helped develop the TRAC language and wrote the first TRAC implementation. Deutsch later implemented Ghostscript.
About 10 years later, Ted Nelson's "Computer Libs" suggested TRAC as one of the first three programming languages to start with. This made people more widely aware of TRAC, and of course people did their own implementations, as seen in this link.
Mooers, though, was very protective about what was "his." He pushed for software copyright production back in the 1960s. The best he could do was trademark the term "TRAC", and send cease&desist letters when someone used it. See this article from the first issue of Dr. Dobbs: https://archive.org/details/dr_dobbs_journal_vol_01/page/n12...
I talked with someone who had met one of Mooers' daughters around Cambridge. He knew Mooers was, and had (as I call) a copy of Computer Lib with him. He got invited to dinner with the Mooers family. All went well, until he revealed he had written a version of TRAC for himself. This was a sore point. Mooers got up and left. He wife commented that Mooers didn't like others playing with his toys.
So I stopped using BankID over two years ago, and do most of my daily life in cash.
reply