A big caveat mentioned in the article is that this experiment was done with a small set (N=47) of specific questions that they expected to have relatively simple relational answers:
> The researchers developed a method to estimate these simple functions, and then computed functions for 47 different relations, such as “capital city of a country” and “lead singer of a band.” While there could be an infinite number of possible relations, the researchers chose to study this specific subset because they are representative of the kinds of facts that can be written in this way.
About 60% of these relations were retrieved using a linear function in the model. The remaining appeared to have nonlinear retrieval and is still a subject of investigation:
> Functions retrieved the correct information more than 60 percent of the time, showing that some information in a transformer is encoded and retrieved in this way. “But not everything is linearly encoded. For some facts, even though the model knows them and will predict text that is consistent with these facts, we can’t find linear functions for them. This suggests that the model is doing something more intricate to store that information,” he says.
It’s totally possible to decouple these if your python outputs plain JSON/csv into the data/ directory that you commit into the repo or generate just before build time. Then you can import that raw json data into an Observable .md file.
But if you want dynamically generated data at build time and want to make use of Observable’s dataloader automatic execution of data/*.json.py, for instance, while still maintaining a custom virtualenv for the project rather than your system python, you’ll need some way to specify that virtualenv’s interpreter while observable executes the build for the dev server or the full dist/ output.
So for both options it’s largely a matter of taste. I personally like using the poetry virtualenv because it’s simple to manage dependencies and the venvs in one tool, while letting me use observable’s dataloaders with third-party or custom python packages. It sounded like the parent comment wanted to use this type of approach so I focused it to that scenario specifically. I like the simplicity of the single command to generate the data and build the site.
I have a setup with poetry that runs the python data loaders in the poetry-managed virtualenv.
I just created a python project and then instead of `yarn run dev` to start the dev server, just run `poetry run yarn run dev` so the python is executed within the virtualenv.
This setup also lets you use a custom python package to define reusable and unit-testable code for the dataloaders that you can import into the *.json.py files to keep those really simple.
Whenever Tipasa comes up, I always think of Camus's quote from "Return to Tipasa":
> But in order to keep justice from shriveling up like a beautiful orange fruit containing nothing but a bitter, dry pulp, I discovered once more at Tipasa that one must keep intact in oneself a freshness, a cool wellspring of joy, love the day that escapes injustice, and return to combat having won that light. Here I recaptured the former beauty, a young sky, and I measured my luck, realizing at last that in the worst years of our madness the memory of that sky had never left me. This was what in the end had kept me from despairing. I had always known that the ruins of Tipasa were younger than our new constructions or our bomb damage. There the world began over again every day in an ever new light. O light! This is the cry of all the characters of ancient drama brought face to face with their fate. This last resort was ours, too, and I knew it now. In the middle of winter I at last discovered that there was in me an invincible summer.
I usually keep Invoke globally installed that way I can use it for setting up and interacting with pipenvs externally. Most of my calls beside the initial setup make use of 'pipenv run <command>' that way I never actually have to navigate inside of the virtualenv for most cases.
I'll second invoke. I use it for all of my python projects now and I love working with it. It makes it very clean to manage more complex tasks that have a lot of conditionals involved.
Yanofsky and Manucci's "Quantum Computing for Computer Scientists" is a smooth intro if you come from a CS background.
Nielsen and Chuang's "Quantum Computation and Quantum Information" is more thorough and advanced from a mathematical point of view. But it contains a primer on the linear algebra required.
There is also some really interesting epigenetics research focusing on age-related disease.
For example, Steve Horvath's group at UCLA has been refining an "epigenetic clock" using DNA methylation data to predict all-cause mortality in several species with a relatively simple test. It has the potential to be an incredibly valuable metric in the field going forward.
This data doesn't seem too reliably sourced. Sorting by ascending years of experience shows negative numbers with the top entry being -9001 and an annual base pay of "a trap a day makes the boner go away"...
Graduated college and finally broke into the software industry. Now I have a manager who respects what I bring to the team and lets me build whatever I want. I thought it would take me a few more years to land a job like this. I feel very fortunate.
I'm the same way, and for me I believe it is a combination of being extremely intrigued and gratefully removed from my own world. Meeting an interesting person (romantic or not) is a great experience for that dual effect of mental stimulation (your "figuring it out" description) and being confronted with another person's reality which may feel much more vibrant than your own.
Also, the deprecation alert on the CodeCatalyst site is incorrect at the moment:
> Important Notice: Amazon CodeCatalyst is longer open to new customers starting on November 7, 2025
https://codecatalyst.aws/explore