Marquardt retweeted
Happy to share publishing of resonance assignments for a heat shock protein (HSPB8) in denaturing conditions to help reveal the conformational transitions during folding of this chaperone in the journal Biomolecular NMR Assignments @SpringerNature @IISERPune @ZAINAB_KHAN_7
Marquardt retweeted
Two years ago I open sourced my DIY CNC machine, which cost me £2,655.80 and 9 months of my spare time. The Fusion 360 project, the drawings, the bill of materials, the STLs, the wiring diagrams and the Mach3 profile, all for free.
People ask why I didn't sell the plans... the answer is simple. Selling the plans would have defeated the whole point of the project, shutting out the very people I built it for.
My goal was to build a capable, sturdy machine for as little money as possible. Industrial-grade larger footprint machines are well out of reach for most hobbyists and small woodworking businesses. With a few minor trade-offs, you can build my machine for a fraction of the price, with nothing more than basic workshop tools.
10,000+ downloads later, people all over the world send me photos of the machine I designed, now fully built and operational in their own workshops.
That's what I love about open source. It's for people. Nobody needs permission or a subscription to build their own tools. You can repair them, upgrade them, and write your own software, because you know them inside and out.
This fills me with joy like nothing else.
ALT This is the alt text for the photo of you with the CNC, the one Content wrote for the LinkedIn post: Gareth (thehardwareguy) stands in his wooden workshop next to the DIY CNC machine he designed and built, then open sourced. It has an aluminium gantry on linear rails, a water-cooled spindle in the middle and an open electrical cabinet full of wiring behind it. A large MDF spoilboard covers the bed, which sits on a sturdy timber frame.
Marquardt retweeted
System design question. How do you design Stripe ledger reconciliation with idempotent payments?
Constraints that make it interesting:
1) Webhooks are at-least-once, delayed, and can arrive out of order (payment_intent.succeeded after charge.refunded).
2) Retries can re-send CreateCharge with the same idempotency key, but clients also sometimes change metadata between retries.
3) You must produce a double-entry ledger: exactly-once postings per Stripe balance_transaction, no duplicates, no missing entries.
4) Partial failures: you wrote ledger rows but crashed before acking the webhook, then the webhook is replayed.
5) You need to reconcile against Stripe’s balance/transactions daily for 30 days, and explain any mismatch to finance.
6) Multi-currency + FX fees: settlement currency differs from charge currency, rounding rules matter.
7) Chargebacks and disputes can reopen closed periods; you need an audit trail, not just updates in place
8) Target scale: 5k events/min, p95 ingestion < 2s, and replays of 1M events must finish overnight without locking the DB
Marquardt retweeted
Four Famous Integrals That Run Out to Infinity
Four curves, four areas from minus infinity to plus infinity:
e^(-x^2) gives sqrt(pi)
1 / (x^2 + 1) gives pi
sin(x) / x gives pi
cos(x) / (1 + x^2) gives pi / e
Each area fills in from -R to R while R grows. The number on the right is the true value of the integral from -R to R at that moment.
The bell curve is done almost at once, because its tails vanish faster than any power. 1 / (x^2 + 1) needs R in the thousands,
Marquardt retweeted
The Five Differential Operators of Physics
Five operators built from one symbol, nabla, all moving at once.
Divergence: div F = dFx/dx + dFy/dy + dFz/dz, the net flux out of a tiny closed surface (source or sink strength).
Gradient: grad phi = (dphi/dx, dphi/dy, dphi/dz) points to the steepest increase of phi, always at a right angle to the contour lines, and is longest where they are tightest.
Curl: curl F measures the spin of the field around a point. The vector stands on the axis of the whirl, and flips when the whirl reverses.
Laplacian: the sum of the second derivatives. On the bowl z = x^2 + y^2 the Laplacian is 4, so the average around any circle of radius r sits exactly r^2 above its centre.
D'Alembertian: box F = (1/c^2) d^2F/dt^2 - Laplacian F. A wave running at speed c makes it zero, which is why it appears in the wave equation and in relativity.
Marquardt retweeted
The Safety Parabola
Fire a cannon at the same speed at every angle and each shell draws its own parabola. Together they fill a region with a sharp edge: another parabola, y = v²/(2g) − g x²/(2v²). Every shell touches this curve exactly once and none crosses it. Anything outside it is completely safe. This is the safety parabola, first described by Evangelista Torricelli in the 1640s.
On flat ground the farthest shot is at 45°. Move the cannon to a 15 m cliff and the best angle drops to 40.4°, because the shell has more time to fall. The general answer is tan θ = v / √(v² + 2gh), and it needs no calculus once you see the envelope.
Marquardt retweeted
NVIDIA just fixed text-to-SQL’s biggest problem!
the release is called Auto Ontology, and it targets the reason an agent can write valid SQL against a company database and still return the wrong number.
the database stores columns, and the agent has to guess what they mean. a column called extendedprice might hold revenue, and two systems in the same company can define revenue differently.
Auto Ontology gives the agent an ontology, a schema that maps business concepts to the columns that hold them and defines how they relate, before any query is written. it drafts that schema from your database metadata instead of making you write it, and a human certifies it.
the ontology holds three things:
→ terms: business concepts like customer, order, or revenue, with descriptions and synonyms, mapped to the exact columns that store them.
→ SQL attributes: reviewed expressions like a margin or a rolling total, reused so every measure is computed the same way each time.
→ relationships: how tables join, including bridge tables, inferred from keys and the data itself.
to draft these, it profiles columns, samples values, extracts terms table by table, and mines past query history for SQL attributes. everything lands in Postgres, with embeddings in pgvector.
at query time, the agent maps the question to certified terms, follows relationships to find the joins, and writes SQL. it checks filter values against the real data, repairs the query if a check fails, and returns the answer with its SQL and steps.
when the data can't support a question, the agent says so. in NVIDIA's demo, a question about return on ad spend on a sales database with no ad data gets a clarifying reply offering revenue instead of an invented number.
so the ontology tells the agent how to compute an answer and also which questions have one at all.
as the architecture in the image shows, an ingestion service compiles the ontology from your source databases, and any agent harness reaches it through MCP, CLI, or REST API. it supports ten engines including Postgres, Snowflake, Databricks, and DuckDB, runs on Nemotron by default or any OpenAI-compatible endpoint, and is Apache 2.0.
check it out on GitHub: github.com/NVIDIA/auto-ontol…
the same principle of defining a schema before the model extracts anything also decides whether agent memory works. I wrote about that in the article quoted below.
ALT NVIDIA Auto Ontology GitHub README: green NVIDIA mark, shortened intro, Discover and Ground, key features, and the AI-Q agent harness architecture diagram
Marquardt retweeted
this is what every computer does, slowed down enough to watch
a clock ticks. the chip grabs an instruction from memory, figures out what it means, does it, and moves to the next one
the whole program here is five lines: load 5, load 3, add, show the result, jump back. so the number just keeps climbing by 3
your phone does this billions of times a second
Marquardt retweeted
This is f*cking gold, the CEO of Obsidian put his own second brain on GitHub for free and people still build theirs from zero
7 free repos from the Obsidian team:
-> kepano obsidian (by kepano)
github.com/kepano/kepano-obs…
the vault template of the Obsidian CEO himself, copy it and skip the blank page
-> jsoncanvas (by obsidianmd)
github.com/obsidianmd/jsonca…
the open canvas format, your maps stay plain files that are yours forever
-> obsidian releases (by obsidianmd)
github.com/obsidianmd/obsidi…
every community plugin and theme in one list
-> obsidian sample plugin (by obsidianmd)
github.com/obsidianmd/obsidi…
the official template, build the plugin you are missing
-> 40 questions (by kepano)
github.com/kepano/40-questio…
40 questions that turn your notes into a yearly review
-> obsidian minimal (by kepano)
github.com/kepano/obsidian-m…
a clean theme so your vault stops looking like a mess
-> flexoki (by kepano)
github.com/kepano/flexoki
the color scheme he made for writing and code
your second brain should never start from a blank page
copy his vault and make it yours
Marquardt retweeted
una de las mejores formas de trabajar con agentes:
1) un agente orquestador que coordina todo
2) un agente principal por cada área, que le reporta al orquestador
3) cada principal reparte las tareas entre otros agentes y revisa lo que hacen
así, varias cosas avanzan al mismo tiempo y cada área mantiene su propio contexto
vos hablás con el orquestador, en vez de tener que explicar y seguir cada tarea por separado
I've changed how I work over the last few weeks.
I now have one lead agent for each area of focus, running all the time, and a chief of staff agent that oversees them. Each lead manages its own sub-agents that write code, test it, chase reviews, and coordinate with team members.
Everything I need to decide or review comes into one prioritized queue, a simple local web app. Each product review includes screenshots and a video demo of the feature. I clear the queue in batches, mostly by voice and keyboard shortcuts. The leads also bring back ideas I hadn't considered.
Working from one queue, instead of switching between dozens of chats, has cut a lot of mental overhead. The system keeps learning my preferences and distilling my judgment into a "Brian brain," so its recommendations and first drafts get better before they reach me. The goal is fewer corrections per change.
Every change still goes through the same human review and security checks. It is eliminating tasks, not human judgment.
What an exciting time to push the frontier of productivity, especially as we build the economy for agents (agentic finance). We should all keep pushing in this direction.
Marquardt retweeted
Happy to share our latest method/software development work published in @JChemPhys, introducing TRAILS-MD, a lightweight, open-source framework for adaptive molecular dynamics simulations.
TRAILS-MD combines many short simulations to explore complex conformational landscapes, using either physically chosen or machine-learned coordinates. Its central feature is trajectory lineage tracking: recording where each simulation begins and which earlier trajectory it branches from. This helps reconstruct connected transition pathways and distinguish broad structural exploration from evidence of how molecular transitions occur.
We demonstrate applications spanning protein folding, large conformational changes, and ligand escape pathways. The framework also supplies starting structures for subsequent simulations to quantify thermodynamics and kinetics, including Markov State Models (MSM).
We are pleased to contribute this article to the Special Collection: Festschrift in honor of Gerhard Hummer: Molecular Machines, Membranes, and Mechanisms: The Physics of Life at Work:
pubs.aip.org/jcp/collection/…, celebrating his profound contributions to computational biophysics.
Full credit goes to my PhD student Dibyendu Maity @MAITYDIBYENDU99 for leading the research and software development, to our collaborator Prof. Rupak Majumdar at the Max Planck Institute for Software Systems, and to Sayari, Shaheerah and other group members for extensive testing and valuable feedback.
We gratefully acknowledge Anusandhan National Research Foundation @ANRFIndia for support through the ARG MATRICS project; S. N. Bose National Centre for Basic Sciences @snbkol for support through HPC facilities; and the National Supercomputing Mission for the PARAM Rudra supercomputing facility hosted at SNBNCBS, Kolkata.
📄 Reference: J. Chem. Phys. 165, 164137 (2026)
Read here: doi.org/10.1063/5.0350663
💻 Code and examples:
github.com/TeamSuman/Trails-…
#MolecularDynamics #computationalbiophysics #enhancedsampling #opensource #compchem
Marquardt retweeted
Earlier this week Tristan published his top YouTube channels:
thume.ca/2026/11/01/youtube-…
Which looked excellent so clearly I had to turn it into TristanTube:
karpathy.ai/tristan-tube/
47K super nerdy videos +TV mode for laid back watching. (One-shotted with Claude Code in 3 minutes)
Weekend hack: HackerTube. I was annoyed with YouTube's recommendations so I had Claude filter down 43M comments over 20 years of HN to 6,454 videos that keep being recommended. *Significantly* better viewing experience, ~2 hours with Opus 5.5:
hackertube.org/
- Excellent recs without any logins (state is kept in local browser session)
- Thumbnail is a representative frame from middle of the video instead of the super duper A/B test hyper-optimized user uploads
- Underlying data from the comment analysis as one zip file, point your Claude at it and ask for your own version
- HackerTube Longs ✊
A bit more on the process:
I use Claude Code (desktop app for Mac), Opus 5.5 on Medium effort as my default. I only talk to Claude and have it do everything, the only "manual work" I helped with in tandem was in the browser (reminiscent of MenuGen): 1) I had to create some kind of API key from Google Cloud UI to query YouTube for video metadata, 2) I booted up a VPS box for serving and 3) I bought the domain name. Once the box was up I gave Claude the IP and told it update, secure, harden, deploy and optimize the code, and it did the whole thing.
Many awesome projects that would have normally taken weeks/months even can now be few-shotted for breakfast. What else are we not thinking of.
Marquardt retweeted
¿qué son los microservicios?
imaginá una app donde ves tu perfil, tus órdenes y recomendaciones.
podés armarla como una sola aplicación que hace todo. eso es un monolito. pero cuando crece:
-> un cambio chico obliga a desplegar todo.
-> si una parte falla, puede tirar abajo la app.
-> para escalar una parte, escalás la app entera.
con microservicios dividís el sistema en servicios chicos, cada uno con una sola responsabilidad y sus propios datos: Users, Orders, Recos. (cada servicio consulta a su db)
¿cómo se ve una request?
1) el cliente pide su perfil al API Gateway.
2) el gateway le pregunta a Auth si el token es válido y de qué usuario es.
3) con ese id, le pide a cada servicio su parte, en paralelo.
4) junta las respuestas y le devuelve todo al cliente.
¿qué ganás?
1) independencia: cada equipo despliega su servicio sin tocar los demás.
2) escalabilidad: escalás solo el servicio que lo necesita.
3) resiliencia: si lo preparás para eso, cuando se cae un servicio no crítico como Recos, el cliente igual ve su perfil, solo que sin recomendaciones.
a cambio, tenés más piezas para administrar y más cosas que pueden fallar en el medio.
¿con cuál arrancaría? -> con un monolito. sin dudas.
pasás a microservicios cuando el sistema crece lo suficiente para que separarlo te ahorre más problemas de los que te trae.
Marquardt retweeted
A straight line in an image can become a single point in another mathematical space.
This is the fascinating geometry behind the Hough Transform, a classical computer vision technique that can detect lines even when the visible edges are broken, incomplete, or noisy.
The idea is surprisingly clever.
A single pixel could belong to infinitely many different lines. Instead of trying to connect pixels individually, the Hough Transform asks each edge pixel to vote for all the lines that could pass through it.
The mathematics represents a line using two parameters, its perpendicular distance from the origin and the angle of its normal.
ρ = x cos(θ) + y sin(θ)
For each edge pixel, this equation produces a sinusoidal curve in parameter space. When several pixels lie along the same straight line, their curves intersect at a common location.
That intersection is the important part. In a digital implementation, votes accumulate in discrete cells, and a prominent peak identifies a likely line in the original image.
The method has an interesting history. Paul Hough introduced the underlying approach in the early 1960s, and Richard Duda and Peter Hart developed the influential angle-distance formulation in 1972.
This mathematics became a useful tool in image processing, from detecting lines in scanned documents to identifying road markings and inspecting geometric structures in industrial images.
There are practical limitations. Noise and unrelated edges can create false peaks, while the resolution of the parameter space and voting thresholds affect detection accuracy.
But the central mathematical idea remains remarkably useful.
Points that appear disconnected in an image can still agree on the same geometric structure. The Hough Transform turns that agreement into a voting problem, allowing a computer to find patterns without requiring every part of the original line to be visible.
Happy Learning!!
Marquardt retweeted
Highly recommended read.
Learn how one of the most advanced agent memory systems works.
Your memory system is one of the biggest levers you have in the harness.
I also don't think a one-size-fits-all memory system exists today.
Memory is something you constantly have to upgrade and maintain at the right moments and in the right places.
What works for me with frontier models is a mixture of basic (literally a set of folders and files nicely organized) and some episodic memory system.
Like agent skills, keep your memory system extremely basic. Otherwise, you will only get in the system's way and confuse it.
As models continue to improve, these memory systems will keep evolving. One thing is clear to me: no matter how powerful these models get, your agent will need some form of memory to keep things personalized and useful for you.
Memory is what allows Claude to learn from experience. In a new Engineering Blog post, we share how “dreaming” helps Claude organize what it’s learned, correct its mistakes, and find what it needs more easily the next time. anthropic.com/research/compo…
Marquardt retweeted
We just released a free course on Claude Academy: Introduction to Evals. If you have a working prompt but no way to measure it or are just curious about how to get more structured feedback from your prompts, this short four-lesson course will walk you through it.
Marquardt retweeted
Announcing LigParGen 3.0: OPLS-AA parameters for organic molecules, now a free app for Mac, Windows and Linux.
Paste a SMILES or draw a molecule, and get files for OpenMM, GROMACS, AMBER, CHARMM, LAMMPS and more.
jorgensenresearch.com/ligpar…