This feels like the phone and server must be secretly talking to each other. They are not. Your phone does not need the internet to receive the code because nobody is sending it a code. It’s just basic maths(insert normans meme)

The phone calculates it. The server calculates the same thing. If both started with the same secret and agree on roughly what time it is, they get the same six digits.

That is basically the entire magic trick.

Not all of 2fa works like this

2FA means proving who you are with two different kinds of evidence, or factors:

• Something you know, like a password
• Something you have, like your phone or a security key
• Something you are, like a fingerprint

SMS codes, push notifications, hardware keys, recovery codes, and authenticator apps all work differently. The offline six-digit system we use via google auth or mircoslop is just TOTP, or time-based one-time password. A password plus a TOTP code is two-factor authentication because finding the password alone is not enough. The code by itself is not magically “two factor.” It is just the second proof.

The QR code is where it begins

When a website asks you to set up an authenticator, it shows a QR code. That square is not opening some live connection to the server. It mostly contains a long random secret and a little metadata about it.

Inside, it looks roughly like this:

otpauth://totp/example:mel?secret=JBSWY3DPEHPK3PXP&issuer=example

The important part is secret=.... The website generates a long random value there. Scanning the QR code copies it into your authenticator app. Now there are two copies, where the math is being done:

your authenticator app  ──> same secret <──  the website

The secret is normally written using Base32, which is just a convenient way to represent bytes. It is not encryption.

This is also why the setup QR code is easy to break. Anyone who photographs it can import the same secret and generate the same future codes. Basically like a second password for the time being.

Turning time into six digits

After setup, both sides runs the same maths to get to the six digit code.

First, take the current Unix time: the number of seconds since January 1, 1970. Then divide it into 30-second windows:

time_window = floor(unix_time / 30)

Every moment within the same window produces the same number. When the next window starts, the number increases by one. That is the little countdown circle in your authenticator app.

Next, combine this time window with the shared secret using a cryptographic function HMAC. Most authenticator setups use HMAC-SHA1, though the standard also allows SHA-256 and SHA-512:

digest = HMAC-SHA1(secret, time_window)

HMAC produces a long, unpredictable-looking result. The actual TOTP standard encodes the time window as eight bytes and then uses a step called dynamic truncation to select part of that result. Finally, it keeps the last six decimal digits:

code = truncated_result mod 1,000,000

The remainder is always between 000000 and 999999, which is exactly the six-digit shape we want. Leading zeroes count, so 004201 is a real code.

In more realistic way, it looks kinda like this:

counter = floor(current_unix_time / 30)
message = counter encoded as 8 bytes
digest  = HMAC-SHA1(secret, message)

offset  = last 4 bits of digest's final byte
number  = 4 bytes from digest starting at offset
number  = number with its sign bit removed

code    = number mod 1,000,000

The truncation details look cursed because cryptographic standards are supposed to be complicated for some reason, but the model is simple:

shared secret + current 30-second window = current code

Same secret, same math, same output.

Why no internet is required

Your phone already has both inputs it needs:

1. The secret it received when you scanned the QR code
2. The current time from its own clock

The website has its copy of the secret and it does its own math. Neither side needs to send the code to the other beforehand. They calculate it independently and only compare results when you log in.

This is similar to two people agreeing on a secret formula and starting their stopwatches together. They can go to opposite sides of the planet and still write down the same answer every thirty seconds.

The authenticator works w/out internet because time still passes. It might even work on another planet, Big if True.

What if the clocks are slightly wrong

Phones and servers are not perfectly synchronized. Your code might arrive near the exact moment one 30-second window becomes the next. If the server checked only its current window, correct codes would randomly fail around that boundary, But they do not work this way, Servers usually check a small range: the current window, and perhaps one window before and after it.

phone says window 1000
server checks 999, 1000, and 1001

This thingy handles a little clock drift and network delay. Too much tolerance would keep codes valid for longer and make guessing easier, so the window stays small. If your phone’s clock is badly wrong, your codes stop working even though the secret is correct.

Why six digits are enoughish

A six-digit code has only one million possibilities. That sounds large until you remember that, computationally, counting to one million is basically nothing. The reason TOTP survives that tiny search space is that you are not supposed to get a million guesses.

The shared secret is the strong part. A good secret has far more possible values than the displayed code, and HMAC makes it impractical to work backward from observed codes to recover that secret. Seeing 381204 now does not let you calculate the next code.

The short lifetime also helps. Stealing one code normally gives an attacker only seconds to use it. But “normally” is doing some work there.

HOTP, the version without a clock

TOTP comes from an older design of HMAC-based one-time password. Instead of the current time window, HOTP uses a counter that increases after every code:

shared secret + counter = code

TOTP basically replaces “how many codes have we generated?” with “which 30-second window are we in?”. That makes synchronization easier because both devices already have clocks.

tldr;

Your authenticator app is not receiving six-digit messages from every service on the screen. It is storing a different shared secret for each account and repeatedly running the same standardised calculation.

When you scan the QR code, the service gives your phone a secret. Every thirty seconds, both sides combine that secret with the current time window using HMAC and shorten the result to six digits.

Nothing is being sent to your phone. There is no daemon whispering codes into it in the background. Both sides simply know the same secret, look at roughly the same clock, and arrive at the same answer.

Very Unix, really: a small secret, a small function, and an unreasonable amount of faith hoping the clock is in sync. If you want the exact recipes, they live in RFC 6238 for TOTP and RFC 4226 for HOTP.

They use ChatGPT, obviously. A friend asks it to explain something before an exam, somebody pastes in an email to make it sound less angry, my cousins use it instead of Google when they cannot be bothered opening five links. It is already a very popular product, and pretending otherwise because normal people do not use it the way we do would be stupid.

But almost none of them use agents.

Nobody I know outside tech is handing a model a goal and letting it work through their browser, manage their inbox, organize their files, book something, or deal with all the small administrative garbage that apparently makes up adult life. There is no feeling that you are missing out if you do not have an agent, no college group chat suddenly full of people telling each other that this thing changed everything, and no equivalent of that period where everybody seemed to join Instagram or start using Uber at once.

This is weird because, at least from inside the bubble, the technology looks ready. The models can see screens, use browsers, call tools, write code, recover from mistakes and keep working for hours. Every large tech company has some version of an agent, and every second startup is building one for lawyers, recruiters, dentists, support teams, sales teams, landlords, or whatever other profession appeared in the founder’s dropdown that morning. The demos look completely insane, the funding announcements say the market is enormous, and then the demo ends and most people go back to moving information between the same twelve browser tabs by hand.

I keep coming back to Google because the difference feels almost embarrassingly simple. Google did not have to teach people that they had a search problem. We already wanted to know where a place was, how to fix something, what a word meant, who that actor was, or why our computer had started making that noise. You opened one page, typed the half-formed question already in your head, and got something useful without understanding PageRank, information retrieval, or whatever was happening behind the white screen.

More importantly, Google did not ask for much trust before proving its value. It did not need your inbox, calendar, files, browser history and credit card to answer the first question. If it failed, you got a useless link and tried again. The product met a need everyone already understood, made it much easier, and kept the machinery out of the way.

Agents begin with a much stranger bargain. Give this model access to a large part of your digital life, explain the task with enough detail that it does not misunderstand you, and then supervise it because there is still a chance it emails the wrong person, buys the wrong flight, fills a form with invented information, or deletes the one file you actually needed. The model might be right almost every time, but the remaining failures matter much more once it can do things instead of merely suggesting them.

So we have reached this funny place where an agent is capable enough to do the work but not reliable enough for us to stop watching it. Instead of completing the task ourselves, we supervise a very fast intern that has read the entire internet and may still experience sudden brain damage halfway through an expense report.

Progress, ig.

There is another part which I think computer people miss because we have trained ourselves to see everything as a system. We look at somebody doing the same annoying task every week and immediately see a workflow: collect these inputs, call this service, put the result there, add an approval step, done. The person doing the job probably does not see a workflow at all. They see Monday.

Their work lives across an email from last week, a spreadsheet called final_v2_REAL.xlsx, two browser tabs, something their manager said during lunch, and a password sitting in a WhatsApp chat. Half the process is an unwritten exception to the other half, and the context needed to automate it exists mostly inside their head. Then somebody arrives with a blank text box and says an agent can automate their workflow, as if describing the workflow is not already most of the work.

What workflow bro.

This is probably why people use frontier models as Google plus Grammarly. Those uses have a shape that makes sense immediately: ask a question and receive an answer, or paste bad writing and receive less bad writing. The model stays inside the box, the output can be checked before it leaves, and nothing happens to the rest of your life because it misunderstood one sentence.

An agent crosses that boundary. It does things, and doing things requires context, permission and trust, which are exactly the three things most agents ask you to provide before they have done anything useful enough to deserve them. We keep treating this as a capability problem because capability is the part the industry knows how to measure, but I am not sure another twenty points on a benchmark fixes the feeling of giving a machine control over the parts of your life where mistakes are annoying, expensive, or embarrassing.

Maybe the real problem is that the current pitch begins with what the agent can do rather than something a person already wants done. It can browse the web, use a computer, call hundreds of tools, remember your preferences and operate for six hours without you. Very cool, but why do I need that?

People did not use Uber because their phones could combine GPS, payments and real-time driver coordination. They used it because pressing a button and getting a car was obviously better than standing outside trying to find one. The complicated technology disappeared behind one clear outcome, while AI products still make the technology the main event. We talk about the model, context window, harness, tools, reasoning effort and prompt, which means using an agent still feels like operating an agent.

Whatever finally reaches everyone probably will not feel like that. Maybe it lives inside the browser and notices that you open the same five tabs every Friday, or it handles one annoying task perfectly before asking for access to the rest of your life. Maybe it earns trust one action at a time, makes every step legible and reversible, and never once asks the user to build a workflow. Maybe nobody calls it an agent at all; you just notice that the expense report is done.

I do think that moment is coming. There is too much capability sitting here for nothing to happen, and once an agent is both useful and boring enough, letting it handle things will probably feel as normal as searching Google does now. But “the models are ready” and “people want this product” are different claims, and the distance between them might be the entire problem rather than some temporary inconvenience we solve by making the model larger.

The interesting question is no longer whether an agent can use a computer. It can. The question is why somebody outside this tiny circle would let it, what they already need badly enough to take that risk, and how the product proves itself before demanding access to everything.

Google became Google because nearly everybody had questions and it made getting answers stupidly easy. Agents become the next Google when they find the same thing for action: something nearly everybody already wants done, with less effort than doing it themselves and less anxiety than handing it to a machine.

Until then, we have the most advanced models ever built opening Jira tickets for people building more AI agents.

Kinda rough lol.

The list has sphere packing, non-sofic groups, circuit lower bounds, quantum games, the closest vector problem, and five other things I understand even less. I know enough theoretical CS to see a few familiar words and not enough to tell you if the proofs are actually beautiful.

So yea, I asked a model to explain what the model had done.

The successful runs used enough tokens to cost around $2,000 at Sol API prices. Humans, with help from the same model, prepared the arguments into a 249-page paper. Astra then formalized them in Lean, and OpenAI released the certificates on GitHub.

Model finds proof. Humans make paper. Model makes sure proof compiles.

Kinda rough place to be standing in that pipeline lol.

The day after, Fernando Borretti wrote Mathematics Without Mathematicians. His point is that people keep finding one last important job for the human. We will pick the problems. We will explain the answers. We will decide what is worth keeping. At the very least, somebody has to understand it all.

Then the models get better and that job disappears too.

I wanted to disagree with this. It would be nice if he was just doomerposting and we could all go back to whatever we were doing. But “humans will have better taste forever” is not a bet I feel great about making right now. Neither is “the models can prove it but surely they cannot explain it.” Every permanent line people draw around us has started looking suspiciously temporary.

What actually bothered me was the Lean part.

The $2,000 makes discovery cheap, but Lean makes the result checkable without trusting the model’s prose or waiting for a person to understand 249 pages. Another model can take the checked result, use it somewhere else, and pass that result further down. Math to science to engineering, and somewhere at the end we get something that works.

The proof never has to fit inside one person’s head.

I know the small version of this from code. I can send an agent into a project I know nothing about and get back a working diff. The tests pass, the feature works, very cool. Then I close the terminal and realize I could not rebuild the same thing on my own.

Sometimes I learned something. Sometimes the task just got completed near me. Both look exactly the same in git.

That is the bit I cannot stop thinking about. Not whether the output is real. The output is real. It is whether anything happened to me while it was being made. Like, did I spend a single brain cell in the process?

And now I am supposed to go learn some of the subjects in that list. Spend a few years getting through the basics while the frontier is apparently doing this.

Amazing timing bro.

If learning was only a long route toward becoming a useful answer-producing machine, then we may be cooked. There is no honest motivational quote I can put here that fixes that.

But then I look at the stuff I already make. X already had a website before I built Xeet. Torrent clients existed before tork. macOS had a settings app before I rebuilt the same machine 254 times with Nix. None of these projects began because humanity was stuck waiting for me to save it. Nor did I make the world a better place or whatever. I saw something, got annoyed, wanted to feel cool, or was just curious enough to see if I could make it work differently.

Having a better tool already available did not kill that feeling.

Maybe math can still be like that. Not “the humans remain economically necessary” or some other cope with a six-month expiry date. Just that knowing a thing and receiving the answer to it are different experiences. A model can give me a perfect explanation, but it cannot do the understanding for me. That part still has to happen in my head.

This does not save mathematical jobs, status, or the whole social world around research. Borretti is probably right that very few people can run on pure intrinsic motivation forever. I definitely cannot predict what any of this looks like in ten years.

I also do not need a ten-year philosophy before opening a book today.

Astra can reach the frontier before I understand the problem statement. Fine. I still want to know why the thing is true.

Maybe that is cope too. idk, ask me again after I figure out what a non-sofic group is.

Atuin says 254 rebuilds. That is twenty since 001, which for me counts as restraint.

A million keys in a month. 189 km of scrolling, which I refuse to think about.

Xeet

Xeet is an X client for the terminal.

I built the first version last September with the official API, because that is what you use. OAuth 1.0a, four credentials, a developer account, an app you have to name for some reason. So before typing 200 characters in a terminal you had to go be an X developer for twenty minutes.

I used it a couple of times and never opened it again.

It sat there until I was talking to blitz about something else, and somewhere in that conversation the obvious thing landed. The website posts fine. It has never once asked me for an API key. I log in and it works, so the browser is already an authenticated client, and I had just decided the developer API was the only door because it is the one with a sign on it.

Months. Over that.

So, DevTools. Post something, watch the network tab. It is a GraphQL call named CreateTweet and the auth is just my session, auth_token and ct0, with ct0 repeated in a header. I replayed it outside the browser and deleted fields until it broke.

That flipped the whole design. Instead of asking you for credentials, xeet auth finds the session already sitting in your browser, checks it, and keeps its own copy in the keychain.

Then Linux happened. I built all of this on a Mac and had quietly assumed a browser is a browser, which is wrong, Firefox and Zen keep their cookies somewhere else entirely. I also had no way to check any of it. So I started sending binaries to vaeseth to run on their machine, and that back and forth is how it actually started working. hehe.

The other half of the work is keeping an unsupported endpoint alive. The query IDs in the URL rotate, so Xeet reads the current ones out of the JS bundles the web app already ships. GraphQL will hand you a 200 with the error in the body. A create request that times out might have gone through, so retrying can post twice, which is why mutations here do a read-only check instead of retrying.

Finding the endpoint was not clever. Anyone who opens DevTools can see it. Sitting on it for months was the actual event.

tork

tork is at v0.3.2.

Best change: the same torrent listed across five indexes now folds into one row and grabs it with every tracker those indexes knew between them. Better swarm, and I stop scrolling past six copies of the same release. Filters, verified downloads, and Y to yank a magnet from anywhere came along too.

brew install tork, yay -S tork, nix run github:melqtx/tork. The nixpkgs PR is still sitting there.

dots

I have been on Helix for ages, that is not the news. What changed is how much of the Mac nix-darwin owns now. System settings live in the config instead of in a pane I have to go find. It is a nice feeling, having the machine written down.

Hammerspoon keeps earning its place. Right command is F18, held it becomes a hyper layer, hyper + h j k l moves focus. Same motion in Zellij, in Helix, and between windows.

nh darwin switch

The site

There is a /links page now, a live feed of things I read.

addlink https://example.com/thing paper

The title gets fetched from the page, and a Discord /link command hits the same worker.

Site is still Hakyll, markdown in, static HTML out, one flake, pushed to Pages. Everything on it that moves is a Cloudflare Worker: logs, links, the hit counter. My photos just live in the repo, so GitHub is my cloud storage now.

Workers are overpowered and I love them. One worker.js, a wrangler.toml, wrangler deploy, live in seconds, D1 right next to it, all in the free tier. Nothing to renew, nothing to SSH into. It is the only piece of my setup that has never broken on me.

Elsewhere

Watched The Odyssey and it was so good. I will defend Nolan in most rooms and this did not make that job harder.

The part that got me was Argos. Twenty years, everyone else needs proof, and the dog just knows immediately, and he has been waiting the whole time for exactly that one moment and then he is done. Sat there for a second after that one.

Also watched Spider-Man Brand New Day, which ruled. Bro fumbled MJ though, and I have not really recovered from it. I am choosing to believe that gets fixed.

meteorsmp is closed now.

I miss it more than I expected to. It was genuinely fun, and I do not think I appreciated at the time that it was a specific set of people at a specific moment and not really a server at all.

Growing up, apparently

I have a bad habit of not finishing things. I pick something up, move really fast with it, get addicted for a few weeks, then drop it like it never existed. There is no plan behind any of it. Whatever has my attention that week gets all of me, and when the high wears off I move on and leave the last thing at seventy percent.

Case in point, I started messing with inference stuff this month. Got somewhere, hit the part where I actually did not understand what I was doing, decided I was too dumb for it, and have not opened it in three weeks. Which is the same shape as Xeet sitting dead from September to now, except Xeet got lucky and had a conversation happen to it.

I do not have a fix. I just noticed the pattern clearly enough this month that I cannot pretend it is not there anymore.

calling this between rebuilds. every 15 days or so ill just dump whatever i was messing with. not a changelog, just like a large log, so i can keep track of time.

tork

tork went from a small torrent search tui to a whole terminal client somehow.

you throw it a search, magnet, infohash, local .torrent file or url and it just figures shit out. groups duplicates, checks the swarm, lets you preview files, handles the download without bouncing you to another app. also got a linux iso section cuz finding official isos shouldn’t take twelve tabs.

working on autopilot too. you can say something like:

tork autopilot "all breaking bad seasons 1080p under 40GB"

and it searches, picks the good results, explains its choices, and asks before downloading anything.

the annoying part is torrent metadata is very chaotic. names, seasons, sizes, quality tags, everyone’s writing them with different levels of iq. correctly classifying stuff is way harder than making the command look cool. idk how far i wanna take it yet.

strict socks5 proxy support now. searches, http trackers, tcp peers all go through it. dht, utp, udp trackers get disabled so nothing leaks around it.

tork proxy tor
tork doctor --proxy-check

submitted it to nixpkgs, as the repo is still kinda new, so they need some kinda signal that people are using it, that part is still in draft. if we somehow manage to reach like 250ish stars (we wont), i guess then i will try getting it into official homebrew too. for now it’s in my tap.

current release v0.3.1 somehow.

dots

fucked with my dotfiles a ton.

tried aerospace, amethyst, basically every tiling wm on mac. they all kinda suck rn. or maybe macos dev beta 3 broke everything. or maybe it’s just me idk eh.

tried nehir too, like niri’s scrolling layout but for mac. used it for a bit and it’s actually pretty good ngl. scrolling wms just feel better to my brain than forcing perfect grids all the time.

still ended up doing the parts i care about in hammerspoon anyway.

hhkb right command remapped to F18, hammerspoon turns it into a hyper layer. hold it + h j k l to move focus. the consistency is nice, F18 + h always means left, whether in zellij or windows or just navigation in general. So it feels kinda natural navigating.

might have a tab problem in zellij lol.

whole mac is still nix-darwin + home manager so after every experiment:

nh darwin switch

and hope i didn’t just invent a new way to break fish. (i actually did)

the site

site’s still hakyll. markdown in, static site out. the whole build lives in one nix flake now.

nix build .#site

builds the haskell generator, runs hakyll, spits out the site. github actions runs the same thing and publishes to pages.

old ci took like 30min rebuilding the entire haskell world every time. now generator and content are separate nix inputs so changing a post reuses the expensive build. with cache it’s usually around a minute.

it got it all somehow lol, but yea its kinda fast now.

hammerspoon stats

weird input numbers on the about page come from hammerspoon.

it watches keypresses, clicks, scrolling, mouse movement, dragging and writes totals to a local json every few seconds. once a day or on publish it copies the snapshot into the site. hakyll reads the json and turns it into that little panel with keys, mouse distance, scroll distance, clicks. completely useless info, which is exactly why i wanted it.

live logs

log panel used to be editing log.md, committing, and redeploying for every one-line thought. funny idea with a terrible implementation.

now log "message" hits a cloudflare worker. worker verifies, cleans it, adds timestamp, stores in d1.

terminal or discord
        -> cloudflare worker
        -> d1
        -> browser polls /logs every 5s

public site only reads from GET /logs. write token stays on my machine. static pages have a loading placeholder instead of old logs baked in.

same worker handles discord /log command too. both use the same validation and db so i don’t have two different systems.

fin

that was basically it. torrents, window managers, and a static website slowly becoming less static.

imma go back, my limit is about to reset lol. see you after the next rebuild.

The thing about being insignificant is that it comes in two two pills, and I’m taking both right now. There’s the normal kind of insignificant you feel at 20. You’re one person. The universe is very large. Your world feels small in retrospect. You haven’t done anything important yet. This is the kind of insignificance that’s almost comfortable(almost) ,it takes the pressure off. You have time to figure things out. Then there’s this other pill I’m taking now, which is more like: I’m insignificant and the timeline is compressing. I look at what these models could barely do in March and what they can do now, and I try to do the math on what August looks like, let alone next March. The extrapolation makes my mind go brrrr. Six months ago, I’d spend an afternoon reading something stupid, try to replicate it and then finally figuring it out, feel proud. Now I describe the problem to Claude, get a solution in thirty seconds, and feel… what exactly? Grateful? Obsolete? Both? The ceiling keeps rising, which should be exciting. And it is! It is exciting. I can build things I couldn’t have imagined building before. I’m learning faster than I ever have. But the floor is rising faster, and I can’t tell if I’m climbing or just being lifted, and I definitely can’t tell what happens when I’m not needed to do the climbing anymore.

Feynman is the only person in history who left a mark on me without me ever meeting him. I read his lectures, watched old videos of him explaining things on blackboards, absorbed this way he had of being completely honest about not knowing something while being utterly delighted to figure it out.(at one point I even knew first 50 digits of pi, just to reach the Feynman constant)

I think about how Feynman would use AI. He wouldn’t ask it to solve his problems, he’d use it to check his own solutions, to argue with, to explore the weird edge cases. He’d probably spend hours trying to make it explain something wrong just to understand where the reasoning breaks down. The tool would be in service of his curiosity, not replacing it. Imagine Claude code playing bongo drums with Feynman. I’m not Feynman. But most days I’m oscillating. Twenty minutes of genuine fascination, then an hour of low-grade dread. I’ll be excited about what I can build with all this, then suddenly terrified that I’m building skills for a world that won’t exist by the time I’m good at them. The feeling that I need to speedrun becoming competent before competence itself becomes obsolete. It’s not even different moods on different days. It’s the same day. The same hour. Sometimes the same five minutes.

I haven’t built anything significant in the last month. I’ve mostly been thinking, reading, paralyzed by the sense that whatever I choose to build might be obsolete before I finish it. Maybe that’s the problem. Feynman didn’t ask “what’s my role?” or “what should I optimize for?” He asked “what’s interesting?” And then he’d just go figure it out, not because it was strategic but because not knowing was slop back then. I’m watching my friends sprint in different directions. Some have suddenly accelerated and are moving at 100× the speed they were before. Others are acting like nothing is changing, still optimizing for normal career paths. I’m stuck in the middle, refreshing my timeline, reading shit I don’t understand(like at all), waiting for some clarity that never seems to come.

The tree metaphor people love, “the best time to plant a tree was twenty years ago, the second best time is now” well, that doesn’t work anymore. What do you do when you’re not sure if trees matter? When the forest might plant itself? When even the metaphor feels outdated before you finish typing it?

I’m trying to figure out how to be 20 right now. Not the normal kind of 20, where you’re supposed to be figuring out your major and your career and making mistakes that’ll make good stories later. But 20 in 2026, when the timeline for “later” keeps compressing. I don’t have good answers. Most days I just feel small. But I think about Feynman, who looked at everything with this open wonder, who thought the universe was there to be figured out and that figuring it out was the point. Not because it would lead somewhere, but because not knowing was worse than knowing. Six months ago I was asleep. Now I’m awake, even if I’m not sure what to do with that wakefulness yet. I turn 20 in August. By then, who knows what the models will be able to do. Who knows what I’ll be doing with them, or if “doing” will even mean what it means now. But I’ll be here. Paying attention. Trying to figure it out. That has to count for something. Ig.

inline math

here’s some inline math: E = mc² and the quadratic formula $x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$.

display math

the gaussian integral:

$$\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}$$

matrix multiplication:

$$\begin{pmatrix} a & b \\ c & d \end{pmatrix} \begin{pmatrix} x \\ y \end{pmatrix} = \begin{pmatrix} ax + by \\ cx + dy \end{pmatrix}$$

physics equations

the schrödinger equation:

$$i\hbar \frac{\partial}{\partial t}\Psi = \hat{H}\Psi$$

maxwell’s equations:

$$\nabla \cdot \mathbf{E} = \frac{\rho}{\epsilon_0}$$

$$\nabla \times \mathbf{B} - \mu_0 \epsilon_0 \frac{\partial \mathbf{E}}{\partial t} = \mu_0 \mathbf{J}$$

complex examples

euler’s identity:

e^iπ + 1 = 0

a sum:

$$\sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6}$$

an integral with limits:

$$\int_0^1 x^2 dx = \frac{1}{3}$$

code blocks

python should be properly highlighted:

def fibonacci(n):
    """Return the nth Fibonacci number."""
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)

# calculate first 10 fibonacci numbers
for i in range(10):
    print(f"fibonacci({i}) = {fibonacci(i)}")

rust code:

fn main() {
    let mut vec = vec![1, 2, 3, 4, 5];
    vec.iter()
        .map(|x| x * 2)
        .filter(|x| x > &5)
        .for_each(|x| println!("{}", x));
}

block quotes

if the individual lived five hundred or one thousand years, this clash might not exist or at least might be considerably reduced. he then might live and harvest with joy what he sowed in sorrow.

lists

unordered list:

• first item
• second item with bold text
• third item with italic text

ordered list:

1. first item
2. second item with inline code
3. third item

tables

mixed content

combining math and code: the fibonacci sequence can be expressed as F_n = F_n − 1 + F_n − 2 with base cases F₀ = 0 and F₁ = 1.

here’s a function that uses memoization:

const fib = (n, memo = {}) => {
    if (n in memo) return memo[n];
    if (n <= 1) return n;
    memo[n] = fib(n - 1, memo) + fib(n - 2, memo);
    return memo[n];
};

the time complexity is reduced from O(2ⁿ) to O(n) using dynamic programming.

that is the whole trick behind text and binary files:

• a text file interprets its bytes as characters using an encoding such as utf-8
• a binary file interprets its bytes according to some other format, such as png, mp3, zip, or a program’s own data structure

both are made of bytes. “text” and “binary” describe how we read those bytes.

the same bytes can mean different things

put the word hello in a file and inspect it:

$ printf hello > hello.txt
$ xxd hello.txt
00000000: 6865 6c6c 6f                             hello

the left side shows the bytes in hexadecimal. 68 represents h in utf-8 (and ascii), 65 represents e, and so on. a text editor knows that mapping, so it shows hello instead of five numbers.

now take the bytes at the beginning of a png:

89 50 4e 47 0d 0a 1a 0a

those bytes are a file signature. a png reader recognizes them and starts decoding image dimensions, colors, pixels, and metadata. a text editor tries to turn the same bytes into characters and mostly produces nonsense. the bytes did not change; the interpretation did.

what makes text readable

an encoding is an agreement between bytes and characters. ascii covers basic english characters. utf-8 covers those same characters plus writing systems, symbols, and emoji from across unicode.

for example, A is one byte in utf-8:

41

the character é takes two:

c3 a9

this is why “one character equals one byte” is a bug waiting to happen. the string café has four characters but five bytes in utf-8. many emoji use four bytes, and some visible symbols are made from several unicode characters.

an encoding mismatch is what gives you text like café. the file may be perfectly intact; it was simply decoded using the wrong rules.

utf-8 is the sensible default for new text files. when opening text in code, specify it instead of depending on whatever default the operating system happens to use:

with open("notes.txt", "r", encoding="utf-8") as file:
    notes = file.read()       # str: decoded characters

with open("photo.png", "rb") as file:
    photo = file.read()       # bytes: the original byte values

in python, text mode decodes bytes into a str. binary mode returns bytes unchanged. writing works in reverse: text mode encodes a string, while binary mode expects bytes.

formats are more useful than extensions

extensions are hints, not proof. renaming photo.png to homework.txt does not turn its pixels into prose. many formats identify themselves using a signature near the beginning of the file:

• png starts with 89 50 4e 47 0d 0a 1a 0a
• jpeg usually starts with ff d8 ff
• pdf starts with %PDF-
• zip commonly starts with 50 4b 03 04, which looks like PK in ascii

some familiar files are containers for other files. a .docx, for example, is a zip archive containing xml, images, and metadata. it has text inside it, but the document as a whole must be handled as a zip-based binary format. this is why the text/binary distinction is useful, but not a perfect taxonomy.

on unix-like systems, a few commands make unknown files less mysterious:

file mystery.dat             # make an educated guess about the format
xxd mystery.dat | head       # inspect the first few bytes
strings mystery.dat | head   # find readable runs of text inside it

file checks the contents instead of trusting the name. xxd gives you an exact view of the bytes. strings is handy when a binary contains error messages, paths, or metadata, but its output is only a clue—not a safe representation of the whole file.

how binary files get corrupted

opening a binary file in a text editor does not normally hurt it. saving it can.

a text editor may try to decode the bytes, replace sequences it considers invalid, change the character encoding, or convert line endings. once it writes those changes back, the original byte sequence is gone and the program expecting a png, zip, or executable may reject it.

line endings are a smaller version of the same problem. unix text files normally end lines with the byte 0a (LF). windows traditionally uses 0d 0a (CRLF). text-aware tools may translate between them. that is helpful for prose and source code, but disastrous if those bytes are part of a binary structure.

when copying or hashing binary data, work with bytes all the way through:

from pathlib import Path

data = Path("source.png").read_bytes()
Path("copy.png").write_bytes(data)

if the copy is supposed to be exact, compare hashes:

sha256sum source.png copy.png

the two hashes should match. on macos, use shasum -a 256 if sha256sum is not installed.

binary data inside text systems

sometimes binary data has to travel through something that only accepts text, such as json, an email body, or an environment variable. base64 solves this by representing arbitrary bytes with ordinary text characters.

that does not make the data human-readable, compressed, or encrypted. it is just a reversible transport encoding, and it makes the data roughly one-third larger.

base64 < tiny.png > tiny.png.b64
base64 --decode < tiny.png.b64 > restored.png   # common on linux
base64 -D < tiny.png.b64 > restored.png         # macos

if a protocol already supports raw bytes—an http response body or a multipart file upload, for example—base64 is often unnecessary overhead.

choosing a format

use text when people should be able to inspect, edit, diff, or repair the data with ordinary tools. source code, configuration, logs, csv, json, and markdown benefit from that transparency.

use a binary format when compact size, exact types, fast parsing, compression, or media-specific structure matters. images, audio, video, archives, databases, and compiled programs usually belong here.

neither one is automatically better. json is easy to debug but can be verbose and cannot directly represent raw bytes. a binary serialization format can be smaller and preserve types precisely, but it needs compatible tooling. choose based on who must read the data and what the system needs to do with it.

the short version

files are bytes. formats give those bytes structure. encodings turn some of them into text.

when a file behaves strangely, do not just stare at its extension. ask four questions:

1. what format are these bytes supposed to follow?
2. if it is text, which character encoding does it use?
3. is any tool silently converting the encoding or line endings?
4. do i need characters here, or do i need the original bytes?

that mental model is enough to explain most file corruption, mojibake, failed uploads, and “works on my machine” encoding bugs. everything else is just learning the rules of the particular format in front of you.