dalke

no profile record

comments

vorige maanddiscuss

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.

vorige maanddiscuss

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.

2 maanden geledendiscuss

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

Here's a copy of the section on encoding methods - http://dalkescientific.com/opto_Bourne.pdf .

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.

2 maanden geledendiscuss

There are two books you should take a look at.

"Methods of Information Handling", Charles Bourne - https://archive.org/details/methodsofinforma0000unse/page/n5... (not available to read)

"Punched Cards: Their Applications to Science and Industry", https://archive.org/details/punchedcardsthei0000robe (can be checked out)

The first of these is a much better book.

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.

Here's a video of someone scanning in edge-notched cards for bird identification. https://youtu.be/MBwP3YOxw3I

About 10 years ago I really go into the topic and made some cards of my own, using a cutting machine to make each card, precut, from an SVG.

3 maanden geledendiscuss

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!

4 maanden geledendiscuss

You might consider prefixing with 'ChatGPT claims…' as a clearer expression of uncertainty.

4 maanden geledendiscuss

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.

4 maanden geledendiscuss

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?

4 maanden geledendiscuss

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.

And that's from a training corpus which almost certainly includes statements that the kids are drawn with 5 fingers, since I confirmed that info on TVTropes and Reddit comments, like https://www.reddit.com/r/pics/comments/swod8/charlie_brown_h... .

4 maanden geledendiscuss

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

Yet if you go to the Wikipedia entry at https://en.wikipedia.org/wiki/Peanuts you'll see the kids have 5 fingers. Or take a look at the actual cartoons. Or read the TVTropes entry https://tvtropes.org/pmwiki/pmwiki.php/Main/FourFingeredHand... under "Comic Strips".

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?

4 maanden geledendiscuss

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.

See https://tuananh.net/2026/03/05/relicensing-with-ai-assisted-... with discussion at https://news.ycombinator.com/item?id=47257803

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++)"?

4 maanden geledendiscuss

The README says "PyMOL-RS is a clean-room rewrite" but when I look at ./pymol-mol/src/dss.rs I see things like:

  //! - PyMOL's layer3/Selector.cpp - SelectorAssignSS function
  //! - PyMOL's layer2/ObjectMolecule2.cpp - ObjectMoleculeGetCheckHBond function
  //! - PyMOL's layer1/SettingInfo.h - Default angle thresholds

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.

4 maanden geledendiscuss

I looked at the PDB parser.

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.

5 maanden geledendiscuss

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

I talk about "$$$$" more at http://www.dalkescientific.com/writings/diary/archive/2020/0... .

Then there's the "S SKP" field, which you'll almost certainly never see in real life! I've only seen it used in a published example of a JICST extended MOLfile. See http://www.dalkescientific.com/writings/diary/archive/2020/0...

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

8 maanden geledendiscuss

Oh, I should have pointed out my Python lexer-driven parser at https://hg.sr.ht/~dalke/smiview/browse/smiview.py

The lexer: https://hg.sr.ht/~dalke/smiview/browse/smiview.py?rev=tip#L3...

The lexer state transitions: https://hg.sr.ht/~dalke/smiview/browse/smiview.py?rev=tip#L3...

8 maanden geledendiscuss

I see you include the dot disconnect "." as part of the Bond definition.

You also define Chain as:

  Chain <<= pp.Group(pp.Optional(Bond) + pp.Or([Atom, RingClosure]))

I believe this means your grammar allows the invalid SMILES C=.N

8 maanden geledendiscuss

That's "SMILES".

Yes. Here is the yacc grammar for the SMILES parser in the RDKit. https://github.com/rdkit/rdkit/blob/master/Code/GraphMol/Smi...

There's also one from OpenSMILES at http://opensmiles.org/opensmiles.html#_grammar . It has a shift/reduce error (as I recall) that I was not competent enough to fix.

I prefer to parser almost completely in the lexer, with a small amount of lexer state to handle balanced parens, bracket atoms, and matching ring closures. See https://hg.sr.ht/~dalke/opensmiles-ragel and more specifically https://hg.sr.ht/~dalke/opensmiles-ragel/browse/opensmiles.r... .

9 maanden geledendiscuss

Link to the actual "etude" https://archive.org/details/wetherell-etudes-for-programmers... (Wetherell has a number of small, interesting programming "etudes", one of is to write a TRAC interpreter.)

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.

9 maanden geledendiscuss

Could someone explain what "democratising" means here? Is it any different than "user-friendly", "enabling" or "simplifying"?

9 maanden geledendiscuss

I ... probably did?

I didn't.

Things were a lot looser then. I brought a 6-pack of Negra Modelo as carry-on for a trip to Europe. The airport x-ray staff in Albuquerque recognized it on the screen, which impressed me. They had no problem with it.