Patrick Jackson

Feature-First Development

Sun, 14 Dec 2025 00:00:00 +0000

For my latest quixotic project I decided to develop it in an unstable, “feature-first” manner. The exact opposite of how I usually develop software.

In the past I’ve usually tried to write code in a sort of “bulletproof” style, with every change and feature being over-engineered, over-tested, and fully reviewed before merging to main. Very similar to how TigerBeetle has been publicly working with their Tiger Style.

I explicitly chose to go a different route in developing Eidetica pre-1.0 and I want to lay out my reasons why.

This only applies to the in-development/unstable phase pre-1.0. As I approach and reach 1.0 I’ll ramp up my stability expectations to make it into a fully stable, hopefully bulletproof backend.

TL;DR - Eidetica will be unstable until the primary features are done, but not a moment longer.

Eidetica Background Link to heading

Eidetica is a decentralized database that is my solution for writing local-first software.

It’s intended to be a “batteries-included” backend for apps that want to be local-first. Store your data/files inside of the Eidetica data model and it will handle synchronization to all client devices. Users will have their data always synced to their local devices in the background, making both always-on network connections and reliance on central servers unnecessary. And by having user data always stored and editable locally there’s no slow-down in the user experience waiting for network roundtrips.

It’s peer-to-peer, optionally end-to-end encrypted, all that good stuff.

It’s also currently entirely unstable. I have a big scary note in my README that everything can break without warning and with no migrations supported.

Why Feature-First Link to heading

Honestly it makes me uncomfortable to develop software this way. Working within an unstable codebase feels icky but it has a lot of benefits for early development.

1. Development Velocity Link to heading

I am building this myself, because I want to get the core designs down first.

But that also means there is only 1 developer, with 0 funding except for my own limited ‘fun’ budget. (I’m FIRE’d, which means I’m rich in time but have a limited budget).

By holding off on stability as long as possible I can avoid wasting time on that when there are very little/zero actual users.

2. Chicken/Egg Problem Link to heading

Without stability there can’t be users. But without users there’s no point in being stable.

However, there also aren’t users without sufficient features. There’s no point in paying for stability until you have to.

3. Don’t Know What I Don’t Know Link to heading

It’s hard to change core configurations while trying to maintain stability.

And the truth is I don’t know the right way to build this.

Sort of.

I gave up on trying to design the whole thing correctly from scratch before building it. It’s too large to fully model without existing code, and I’m trying to avoid making a wrong decision in the core that I will have to support forever.

Because of how Eidetica is built it keeps the entire immutable history around, so if there is a mistake in the design it will likely live forever.

And I know there are mistakes! I’ve already fixed a bunch of them!

Instead of trying to figure all those out from the beginning I am building all of my primary hero features before stabilizing. Focusing on the ones where I’m unsure how or if they can fit into the existing strategy.

4. All Features are Required Link to heading

The subset of Eidetica that needs to be built and stable in order for apps to use it is actually quite large, larger than I thought back when I started. And that number only grows larger when I add in the features on the roadmap that may have an impact on the core.

Here’s an incomplete list in no particular order:

Built-in CRDTs
Bring your own CRDTs
Efficient state caching
Large Table support
Multiple Hash function support
Multiple private Key types support
P2P synchronization of the Database
P2P object storage synchronization
Basic Encryption
Good Encryption
Database Management facilities
Background service
Local client-service communication
History browsing
Authentication and Access Management
Administration/Moderation
Sparse Checkouts
Fast Initial Sync
Bootstrapping

And probably more I can’t think of right now.

Some of those are already built, some of those I have solid designs for how they will work and can wait for 1.0, and some of which I’m completely unsure of.

I’m trying to target things that are definitely essential, and then have reasonable plans or ideas of how others can fit into the existing design without breaking it.

How to Stabilize Link to heading

Since I’m building so much unstably I will eventually need to stabilize it. For that I’m doing 2 things very intentionally.

1. Layered Design Link to heading

The majority of the features are being built on top of Eidetica itself.

Authentication/key management reuses database administration primitives
Instance management, user data, and synchronization info are all being stored in Eidetica databases even though they don’t need history or synchronization
My own features all use my own simple CRDTs
Etc.

As much as possible it’s being built in this sort of “nesting doll” style design where each layer builds upon the one below it. As I build and test more features, the lower layers of this stack stabilize with bug fixes and cleanups as I build features on top of them and find more issues.

Basically, Eidetica itself is the first consumer of the Eidetica primitives and design as much as possible.

2. Extensive Testing Link to heading

My philosophy is that compute is cheap and dev time is not, and that still applies even though I don’t have a salary.

That’s not to say that I don’t care about efficiency in my code, far from it actually, but rather that CI, testing, and other development support things can and should use computing power to save dev time. If the goal is for the final built code to be run at scale then having a few machines constantly making sure it’s fully tested and fuzzed should be the default.

TigerBeetle, for example, constantly uses 100 cores just to run their simulation testing infrastructure. Eventually I’d like to emulate that for Eidetica.

I like having lots of test coverage via unit tests and integration testing, and I plan to also build out fuzz and simulation testing once I approach a more stable base.

Conclusion Link to heading

So for Eidetica it seems to make the most sense to build out this unstable foundation that is underpinned by solid Computer Science theory and research, then transition my efforts into large amounts of testing/stabilizing once the essential features are in place.

Instead of trying to determine the exact right path from the beginning, this route of trying to build the whole system in an unstable manner has been working remarkably well.

Well, maybe. It’s certainly allowed for a very high development velocity right now, and I guess time will tell if it leads to a solid, stable design in the future. I’m more comfortable and experienced with the ‘stable’ development style so I am reasonably confident that that will go fine.

So in short: Eidetica will be unstable for as long as is reasonable, but not a moment longer.

Sync Conf 2025 Trip Report

Fri, 14 Nov 2025 00:00:00 +0000

I just got back from spending 3 days of my time and more than $1000 to travel to and attend a conference. For my “side-project” Eidetica.

What can I say, I’m a tech geek with free time and I had some room in my budget.

I didn’t socialize/connect/chat very much as usual, but that wasn’t the point this time. I wanted to see and hear in person from other projects in the space.

I had already researched most of the projects on my own, but I did find a few gems that made the trip worthwhile. Additionally, seeing all these things made me more confident in my approach and plans for Eidetica. Most of these “sync engines” are thinking too small for my liking, or they’re trying too hard to productize.

If I remember I will come back through and add links to the posted talks in the future.

These are my cleaned up notes about some of the talks, you can see the full schedule: https://schedule.2025.syncconf.dev

DialogDB Link to heading

I think most people tuned out these guys’ presentation. It was late in the day, they did some weird skit, but what they said was great. I may be biased since their README and docs read almost identically to my own, with many of the same references. From a technical standpoint it is probably the most similar thing that I’ve seen to Eidetica.

They are using Datalog for queries, which I had never heard of before. It appears that it’s just their own internal way of handling the data and conflicts. It has nice properties, but it’s sort of an unnecessary constraint in this system and I am nearly certain I can implement what they are doing here as a custom Store implementation in Eidetica. Neat to learn about though; I’ll have to dig into it more. It does seem to have very good synergies with the decentralized architecture too.

Now the most interesting was their use of Prolly trees to store the Database info. I was already planning to use Prolly trees for storing objects; it enables efficient data sync in instances where there is partial data duplication with other existing objects. IPFS uses it for their object storage and hashing as well.

Using a variant of Prolly trees to store the actual Data though is a great idea that I had not thought of in this context. Finding places to apply those principles outside of just object storage is something I’ll need to think about some more and add to my toolkit.

Graft Link to heading

I had looked into Graft before, and I liked hearing about it more; however, it fails to meet my bar for decentralization. It’s technically interesting, and funny enough, is a backwards way of learning about how SQLite stores data on disk, but the concurrent writes story seems relatively poor.

It should work great if you have a single Writer and you want clients to efficiently read from the DB at the edge. It locally hydrates only the needed data from object storage, but my guess is that it struggles in any scenario with writes. It seems to mostly require a global write lock.

Jazz Link to heading

Jazz I had also looked into before, and the talk was on turning their Sync Engine into a Database, which is something I’ve been thinking about too. (See my recent post on CRDTs as databases.)

Turns out that their customers had realized it should be closer to a Database before Jazz themselves did and had requested features.

The main request seemed to be for some way of having global consistency locks. It seems like users want to, at least temporarily, turn the database into a live distributed database instead of a decentralized database. I’m not sure if their requests would be satisfied by the way I have implemented Transactions, but I’ve added this idea to my backlog to consider.

Actually, I believe that simplifies to a request for Users to be able to invalidate some data themselves, which is a mild problem. In the decentralized system, if you can just write something and say ’this is a global lock,’ you can in theory just reject/overwrite any data branches that disagree with that assertion. Planning along those lines are why I set up power levels in my authentication scheme.

For the most part though, I’ve been operating under the assumption that User data must not fail to merge, and that invalidating entries because of authentication or other reasons would be the sole responsibility of Eidetica. That lets me make certain simplifying assumptions during implementation.

Letting User data fail to validly merge is something I’d been thinking about though, but I’m not going to commit to it yet because there is already a workaround. If Users need to write their own “I failed to merge” logic into a custom Store (CRDT), then they can also just silently drop the data.

Ditto Link to heading

I don’t have much to say about Ditto. I had seen them before, and they’re the closest product to what I am building.

I think they were also the ones who mentioned having concepts for different types of nodes: servers/sparse clients, etc. This is also in my plans.

I do (and already have) recommend them to people for their use case in syncing data in flaky network environments.

Convex Link to heading

They send a deterministic TypeScript (why? why not WASM?) blob to their server to run against the database and return the results. They also track the inputs so they can cache the full query.

Eh, this looks like it’s just query-based requests. From what I understand, it’s similar to GraphQL and is something I’d already been thinking about how to do.

For my purposes I can’t always assume that the remote server has access to the underlying data since it might be E2EE. My plan was to update my Sync code to support a set of requests for which Entries to pull: “All children of X,” “The most recent YY Entries for Z Store,” etc. Better requests based on the data may also be something I consider later.

Notion Offline Link to heading

Notion built their own CRDT to store their block data to allow for offline editing. Makes sense, it’s good to know. I enjoyed their talk describing how they did it. Was probably very useful for people who had not seen how CRDTs are built.

SQLite Persistence Link to heading

An entire talk about how you can store SQLite objects in a browser client. This is how I planned to implement my WASM build for Eidetica, but I’ll learn it from docs.

I enjoyed the talk though, and learned a good amount, but I don’t have lots of notes.

Using CRDTs + Sync as a Database

Tue, 04 Nov 2025 00:00:00 +0000

Can you use a CRDT as a Database?

I’ve been thinking about this a lot, and my answer is a resounding…

Maybe

Depends on your data, and your use case.

If your data is a good fit, and you’re ready to take on the quirks associated with doing so, I’m working on a batteries-included, decentralized DB that will store/track history/sync/query/authenticate/encrypt for you. Choose Eidetica as your database, and get all of that for free.

Let me explain.

Also to be clear, Eidetica is AGPLv3 licensed (see my thoughts on licensing) and I’m not ready to accept outside contributions yet but will soon. I will hopefully offer it under a Commercial License in the future but it will always be available under an OSI approved license.

Also also, it’s proof-of-concept, experimental and no backwards compatibility guaranteed for now. It is definitely pre-Alpha quality. Some of the purported features here are mild overstatements of the current capabilities. If you use it in prod in the near future I will laugh at you.

What is a CRDT? Link to heading

Conflict-free Replicated Data Type is a type of data structure that you can merge without conflicts. In essence it lets you and I separately create updates to a base set of data, and our changes can be deterministically merged together without failure.

A write to the CRDT can happen without confirming that it’s the only write happening at once. This is the key difference between distributed and decentralized systems:

Distributed systems (like traditional distributed databases with Raft or Paxos) require coordination before accepting writes. When you write, the system must confirm with other nodes to maintain consistency, which means you need network connectivity and consensus.
Decentralized systems (using CRDTs) allow each node to accept writes independently without coordination. You can write to your local copy while completely offline, and when nodes eventually reconnect, the CRDT merge algorithm automatically reconciles all changes deterministically.

This “write locally, sync later” property is what makes CRDTs powerful for local-first applications.

It can be as simple as coming up with a deterministic order to the changes and then taking the Last Write Wins (LWW). Technically that results in no conflicts being possible, but there can be logical errors that result. For example, with naive LWW: Device A sets status = "completed" and assigned_to = null, while Device B sets assigned_to = "Bob". You might end up with a completed task still assigned to someone.

Simplified CRDT Link to heading

For the purposes of using it inside of Eidetica’s syncing framework, a CRDT needs to have the following properties:

Merging in the same order is deterministic and results in identical data.¹
Merging 2 CRDTs can’t fail, it is always valid.

That’s all that Eidetica relies on.

Eidetica: CRDTs + Everything Else Link to heading

CRDT libraries like Yjs and Automerge provide CRDT implementations but they’re only the data format, not complete systems. While there are sync engines written to on top of these like Automerge Repo, most only work with a single CRDT type.

Eidetica is generic over CRDTs. You can use the built-in simple CRDTs (like a LWW table or document store), plug in Yjs or Automerge types, or write your own. Eidetica doesn’t care what CRDT you use.

What Eidetica provides is everything else you need to build a database:

Sync protocol: Uses Iroh for peer-to-peer networking
Authentication: Decentralized identity without a central authority
Transactions: Atomic updates across multiple stores/tables
Storage backends: Persistent storage with history tracking
Object storage: For large binary data (separate from CRDT state)

Think of it as: CRDT Library + Sync + Auth + Storage + Transactions = Eidetica

CRDT as a DB Link to heading

CRDTs work well for human-generated data in modest amounts per user. They don’t work well for high-volume writes from many nodes.

For the data most precious to you - private notes, todo/contacts/calendar, communication, etc - this model should map pretty well. A chat app, for example, can easily be built on top of this without much effort. I’ve written a small, TUI chat application to demonstrate.

Note: The underlying format in Eidetica is quite similar to Matrix and will have similar horizontal scaling problems. Matrix has included a lot of additional niceties for a chat service that make scaling for them even more difficult though.

I specifically designed things this way because it’s how I want my personal data to be stored. I want my data provably verified, End-to-End encrypted, and available on all my devices even if I’m offline. I hate showing up somewhere and having no access to my notes, todo list, rss feed, or chat history because the internet is down. Apps should sync in the background whenever my devices are on.

CRDT State vs. Object Storage Link to heading

Not all data should live inside the CRDT itself though.

The data stored inside the CRDT type should be relatively small since the system stores the full history and signs each commit. For large or binary data like images, videos, or large documents, it’s more efficient to store a hash reference in the CRDT and keep the actual object outside the CRDT state.

For example, in a note-taking app:

Store in CRDT: note title, tags, creation date, description, and the text content.
Store as Object: attachments, images, videos, etc.

This way you can garbage collect and deduplicate objects independently from the CRDT history, which can’t easily be modified or pruned. The CRDT gives you the structural data and references, while the object store handles the heavy content.

In Eidetica, Object Sync will be a separate storage layer with different configuration options but is not yet implemented.

Is This Correct? Link to heading

Personally I think that a whole lot of data can be modeled as a “CRDT”. I’m taking a bet on that by working on Eidetica to build out exactly the storage/sync system that I personally want to have.

This is the type of thing that I think allows for a more local-first world. Moving things out of centralized, controlled data and into the hands of users. Each user should own and End-to-End encrypt all of their own data so that no government can monitor you, and no corp can sell ads off your data unless you let them.

And you don’t have to store your data on Google/Meta/Signal’s servers just to have some private chats, or share private data between yourself and your friends. From a purely technical standpoint that is unnecessary. It’s just tricky to get the support and user flows correct, and there’s probably not much money in it.

I will fully admit that it does not work for every type of data, but I do think it applies to more areas than you think.

Is Eidetica For You? Link to heading

So my pitch is this: if you are an app developer, and you can store your data in a format where you can guarantee that you can always “merge” data, and your data storage needs PER USER are relatively modest, then Eidetica can/will provide sync, authentication, encryption (TODO), etc. You don’t need a central server, but you can run my sync server yourself to store/sync your user’s data. You will eventually be able to sync objects as well (TODO).

A user will also be able to run Eidetica locally as a service to store the data from all their local apps using Eidetica and sync in the background.

If you choose to store your data in Eidetica, it gives the User full control over their own data, they can choose how much or how little to store locally, store it on their own servers, rent space on someone else’s Eidetica service for backups, etc.

It is exactly how I want to store my own personal data. I built it for myself first, but I hope it can be useful to others as well.

Some CRDTs don’t care about needing identical order and only need to include the same edits to have a final deterministic state. In effect these are internally managing the state updates and not using a LWW algorithm. From Eidetica’s perspective we could eventually reduce the cost of our state computation and let the CRDT structure handle it so we don’t do it twice, but for now is an unused property. ↩︎

I Let AI Vote For Me In The Nix SC Election

Sun, 02 Nov 2025 00:00:00 +0000

Discuss and yell at me on Reddit along with the people who didn’t have time to read the 1263 words in this post but somehow did have time to read all 188,283 words from the candidates: https://old.reddit.com/r/NixOS/comments/1onhpbt/i_let_ai_vote_for_me_in_the_nix_sc_election/

Update: Something I did not realize until later, there were 24 candidates and approximately 550 eligible voters. More than 4% of all eligible voters were also candidates.

I know, kind of a clickbait title. I’m sorry.

The Nix Steering Committee (SC) election finished this weekend, and I had been putting off voting in it.

The SC is a 7 member committee serving 2 year terms that is sort of in charge of the overall Nix project, and there is always drama with them. To be honest, I still don’t know all the details of exactly what they do or are in charge of, but I do know a little bit about the drama. Just to get an idea, here’s what I remember off the top of my head:

One of them took a job at a weapons manufacturer, which also sponsored the main Nix conference.
The moderation team (a separate group) fully resigned over interference from the SC, I think that was last year?
Conflicts of Interest are rampant in Nix leadership, which is sort of inevitable with a large OSS project, but Nix is pretty bad.
Last month 1 of the members resigned after 1 year of their 2 year term, so 5 of the 7 seats were up for election.

I’ve not been following the drama recently as I’ve been heads-down working on Eidetica, but I still use Nix for my personal machines and my projects. I still donate to them and contribute to Nixpkgs on occasion, even though I have moved over to using Lix instead of CppNix.

I also have strong feelings about SOME of the issues facing Nix but not all of them, so I really wanted to vote in this election.

Timing Link to heading

Unfortunately I’ve been busy, so I got a final “last chance to vote” notification while on vacation. I ultimately had about an hour available to do this before needing to head off to dinner.

However when I looked at the details I hit a small snag…

Voting Hell Link to heading

Candidate info was stored in a git repo. Each candidate had their own markdown file where they explained their positions and filled out FAQ’s sent in by the community to the repo. That’s actually a great setup for a code-adjacent election, I like it.

So I downloaded the repo to start looking.

Problem 1: 24 Candidates Link to heading

There are 24 candidates who have put themselves up for the committee. I know some of them, and one of them even pinged me on Matrix recently (don’t know why, because they need to read nohello.net and I always assume a “hi” with no context is spam).

Ok, this’ll be fine, I’ll read some of the statements and just vote for the ones I know I agree with.

Problem 2: Fully Ranked Choice Voting Link to heading

The voting is ranked choice, which is great! An excellent way to vote for people, especially when there are 5 slots to fill from 24 people.

Unfortunately, it forces me to rank ALL 24 CANDIDATES.

Well that sucks, but I understand statistics and I’m not sure which method of ranked choice they’re using, so I don’t want to just pick randomly for the remaining candidates because I know that can mess with the rankings (I think? Maybe? I’m not 100% on that, but why else would they make us rank EVERYBODY?). So I guess I’m going to look at more of the candidates to try to rank them. How bad is that going to be?

Problem 3: Size Link to heading

> cat candidates/* | wc -w
188283

Wait… Is that… are there 188,000 words in the candidates folder? What the hell?

That’s… hold on.

> 188283 / 24
7845

That’s nearly 8000 words per candidate. I can’t read that right now.

Timeline Link to heading

Now 10 minutes have passed. I skimmed a couple candidate profiles before I realized how the voting worked. From references they each make, I’m now starting to get an idea of how much random ass-drama there has been in the Nix community lately.

(I’m not going to go into detail about what the various drama’s are in this community, that’s for some other time.)

But now I have more context, and this is a problem. I really don’t want to skip voting just because it’s annoying, because I have strong feelings about some of these issues and I enjoy complaining about Nix leadership a lot in private. And as a rule I won’t complain about things when I can do something about it and choose not to.

But time is running out. And I don’t have time to read 200,000 words.

So let’s use the skills I’ve been cultivating with code. I’ll do this with an LLM.

Solving with LLMs Link to heading

I’ve been using these newfangled tools extensively for coding, and conveniently, I already have all this data in markdown files or website links, so I can quickly spin up a workflow for this.

Here’s what I did:

I wrote up a list of things I cared about to serve as my value set. I compiled them from skimming several candidate descriptions and explicitly addressing some of the things I cared about. Mainly, these took the form of statements like “I want X on this issue, I think Y is a problem, I prefer candidates who Z, etc.”
Because of the size of candidate files, I batched the reviews for my LLM of choice and had it check 2 at a time.
For each batch, I instructed it to summarize the candidates and their views according to my values, and place the resulting summaries into a summary file.
Once complete, I had it read that file and my value set again and then rank the candidates.
For verification, since I had limited time, I compared them against the ones I had randomly picked and spot checked a few more at various points in the ranking scale. I confirmed the summaries and rankings matched with what I could glean from scanning the candidate statements.

Notice: I DID NOT just tell it to vote for me. I DID NOT trust the output without verification. And I DID understand its context limitations and work around them.

Would I Do It Again? Link to heading

Yes, but only for things I simply don’t have time to fully review myself.

If this came up again and I did have more time, I would probably start with this method for an initial ranking, and then use that list as a starting point and adjust it more as I reviewed them myself.

Unless I have no other choice, that’s how I think LLMs should be used. They’re an enhancement to my own capabilities, a “bicycle for the mind” to be cliche about it. They are extremely fancy autocomplete that can do a limited set of actions on text but can’t be fully trusted. Their values can’t be trusted, their actions need to be reviewed and verified.

I use them only for things I already know how to do; they just help me do it significantly faster.

I’m sure that many people will have problems with me voting this way, and TBH I don’t really care. I’m happy to listen to your complaints only if you can seriously claim that you read all 188,283 words from the candidates.

OSS Licensing Sucks

Fri, 05 Sep 2025 00:00:00 +0000

I am working on Eidetica, an OSS project that may one day be a good backend for apps to store data. It is primarily useful as an open library for free software to use but may be valuable enough for companies to use and pay for.

What !%&*-ing license should it have?

I basically want a license that says “use it for free, but if you make money you have to pay for it.” I don’t actually care so much about keeping the source code always available, or forcing all users/forks to share code. Don’t get me wrong, those are all good things and I want them to happen, but it’s not a requirement.

What I do care about is that Amazon can’t take it and make hundreds of millions of dollars off it without giving me a penny.

The reality is that none of the broadly accepted Open Source licenses satisfy that criteria. I understand that technically that wouldn’t be an Open Source license, but the community needs some accepted license that allows software developers to both share code where possible but also keep enough control to make money from it.

Lets analyze the potentials, with my requirements, and compare to see which may fit well.

Update December ‘25: To keep in mind while reading, my intention now is to use AGPL + Commercial, and require a CLA that assigns copyright to me with the agreement that the code must always be offered under an OSI approved license. This is exactly what Matrix/Synapse/Element does. This will allow me to sell exceptions for funding, while also giving contributors assurance that the code will always remain open source.

Perspective Link to heading

First we need a lens to view this through. I’m building the following.

A decentralized, Peer-to-Peer Database and integrated Object Store.
Packaged as a library so you can embed it in your own application.
Written in Rust, with bindings for WASM.
Plus a self-hostable Synchronization Node with multi-user support.

Fundamentally it is a database that communicates over the network, offered as a library and a binary. It can be embedded into your app, and can communicate with a hosted Sync server or a users private Sync server to assist with replication.

What license should it use? Should the binary be a different license?

The main problem is that I can’t both distribute the core of the library so that others can embed it into their OSS applications and also somehow charge for it.

The value of this thing is in the protocols, the flexibility/modularity of the codebase, and the interoperability of storing all of a user’s data into the same decentralized system.

For example, if a user is using several different applications that all store data in Eidetica, all the user needs to do is run a Sync node on their laptop/desktop/server and all the data from all of those apps will be backed up there. Or pay someone to host that node for them.

Complete user control of their own data. End-to-End-Encrypted too.

Licenses Link to heading

Functional Source License (FSL) Link to heading

The Functional Source License (FSL) is a Fair Source license that converts to Apache 2.0 or MIT after two years. It is designed for SaaS companies that value both user freedom and developer sustainability. FSL provides everything a developer needs to use and learn from your software without harmful free-riding.

This is the closest thing to what I want. It allows the use of the code for non-competing purposes, and explicitly allows for non-commercial research, education, and even internal use. Basically, it’s for SaaS companies to release their code under a license that allows all uses except those that undermine their business.

But I don’t have a product I’m selling, and I don’t want to be in the business of selling a SaaS product. Technically I could host a Synchronization Node and sell access, but I don’t think the FSL would be appropriate for the library anyway. What is a “Competing Use” to a free library?

One option to consider is to split the licensing for my library and my binary. License the binary under FSL and the library under something more open, but the reality is that all the goodies live inside the library and not the binary, so that they can be embedded.

I love the idea here, and will fully advocate that anybody developing a SaaS should consider it, but it does not work for Eidetica.

AGPL Link to heading

AGPL is the strongest copyleft license that legally forces anyone using your library and providing access over a network to release all their source code. Technically it doesn’t say that, but it has never been tested in court whether communicating with AGPL-licensed software at all makes your code required to be available. No matter what Free Software advocates may claim, multiple companies with huge legal teams ban it entirely because they are not sure how a court would interpret it.

And that is why a bunch of companies with open source communities and a desire to make money use it. Redis and Matrix/Element just off the top of my head.

They license the code as AGPL plus commercial. So you can use it in OSS software as AGPL software while they also retain the right to sell exceptions. It’s how they manage to make money at all, though in both of those cases they also sell hosted versions.

This is the license and plan I’m currently using, but I am wary.

The issue is that I want OSS projects to use it. And you simply can’t license a library as AGPL because it functionally forces anything depending on it to also be AGPL. OSS projects can’t just change their license easily* (all contributors must agree to the new license), so this makes the library a complete non-starter for most existing projects.

*To clarify, an OSS project could in theory add an AGPL dependency without changing its license, however any resulting binary that contained the library would need to be AGPL. Yes it’s a little confusing.

Because of the uncertainty and hurdles, choosing AGPL will heavily limit adoption, and the value of this is quite literally in the network effects.

Permissive (Apache/MIT/etc) Link to heading

A fully permissive license would place virtually no restrictions on the code except for attribution.

Everybody could use it, everybody could make money off of it, and nobody has to pay for it in any way.

Oh…

Free Software, But Paid Link to heading

And here we get to the real problem: the downside to a permissive license is that there is simply no way to make money off the software.

Begging for donations does not work. The number of people who actually earn anything close to a reasonable ROI is approximately zero. I give a good amount of money to the OSS software I use (>$500/year) but most people do not or cannot.
Offering consulting/support sounds reasonable, but I’m not sure how widespread this is in reality. It also causes conflicts of interest that can reverberate through OSS communities for years.
Grants from OSS software support funds. I’ve seen similar projects get funding through these.
Selling it as packaged software isn’t an option, it’s free.
Selling a SaaS myself as “the expert who knows how to manage it” is not something I want to do even if I could get paid for it. It will eventually support arbitrary, E2EE data… I’m not going to host that for strangers.

Buuut, I also have a secret power. I don’t really need income to work on this full time. I am retired (FIRE’d), so I do what I want, and what I want now is for this piece of software to exist.

I am a proud Architecture Astronaut, heavily prone to getting nerd-sniped, and with lots of time on my hands.

I like the tech space. I enjoy digging deeply into so many different areas and getting to play with a useful, foundational piece of software. I also see deficiencies in the existing solutions I’ve examined, and I don’t want to go re-architect somebody else’s project to fix those problems.

That said, I also do not actually want to ‘work’ for free, and I don’t want people to make money while relying on this company-sized project that I have built. I will lose interest and move on.

That’s sort of why I’m leaning towards just using Apache 2.0 and then hoping I can beg for enough donations to cover my direct expenses at least. Maybe it leads to more, maybe it’s just fun to work on for a bit.

To be perfectly clear, my expenses just to be an active software developer are in the thousands of dollars per year (home office, fast computer, hosting, developer tools, coffee, etc.). And since I’m effectively working full-time for myself instead of taking a job, the opportunity cost is in the hundreds of thousands per year.

My Plan Link to heading

I’ve been getting closer to a minimally viable release, when I will start talking about it more publicly. For now I am the only one having written code for it and fully retain the rights to change the license however I want.

I am leaning towards just placing all this code under Apache 2.0 and calling it a day. More than likely it won’t gain wide usage and I will get bored of quixotically developing a database for nobody and move on to something else. TempleOS is not something to aspire to.

If it does become something that people use, I will however attempt to earn money through shaming people for donations, support contracts, consulting, etc., and be very open about conflicts of interest if they arise.

Conclusion Link to heading

After looking at this, I gotta say the landscape is bleak for anybody who wants to try to monetize a project that needs to be some form of OSS to gain usage. The only reason I can even consider going the permissive route is that I do not need to worry about paying for food.

I don’t see any licensing route here that would allow broad adoption, monetization, and restricting Amazon from stealing it without paying any money, all while still being “acceptable” to the OSS community.

I do not see how this product could exist without someone donating a large amount of time and effort on developing it. Pay will almost certainly be less than minimum wage for what is high-skill work, and my altruism is not infinite.

Stay Out Of My (Project) $HOME

Mon, 30 Jun 2025 00:00:00 +0000

Warning, I’m about to get on my mild OCD soapbox again.

Too many development tools expect to get the privilege of a config file in the root directory of my projects. Many of them don’t even allow it to be a hidden file—they just require a fully unhidden “tool.yml” file sitting right there in the root of your project.

Stop it. Please.

Linux HOME Directory Link to heading

Once upon a time this was a serious problem for organizing files in the Linux HOME directory too. Tools thought way too much of themselves and added files, directories, etc. to your HOME folder. A lot of them still do!

Eventually some form of “Standard” was formed. XDG Directory Specifications laid out a set of folders and their uses that could be mostly agreed upon.

~/.config: configuration files, often in ~/.config/toolname/
~/.local/share: application data files
~/.local/bin: user-specific executables
~/.cache: non-essential cached data that can be deleted
~/.local/state: persistent state data that should survive between restarts

I’m sure people complain about this system, but it’s good enough to impose some minimum amount of organization on the HOME folder. It does its job.

Not all projects use it, but it’s common enough that if a project becomes large enough and doesn’t support XDG directories, there’s usually some people who will show up and beg for XDG support. They might even help!

Projects Link to heading

Code project repos are faced with the same problem, though on a smaller scale.

Build systems have their own project layouts they either impose or prefer, but other tools often end up polluting the main project directory.

Take a look at my Eidetica project that I’m developing. I’m still in early development stages, I don’t have any release flows set up, it only uses a single primary coding language (Rust), and yet the home repo still has all the following:

├── Cargo.lock
├── Cargo.toml
├── LICENSE.txt
├── README.md
├── Taskfile.yml
├── cliff.toml
├── deny.toml
├── flake.lock
├── flake.nix
├── .prettierignore
└── .github/

It’s not too bad yet, but the cruft has already started to form. More established projects are significantly worse.

And that’s without having set up Docker, CI beyond basic GitHub Actions, or many other common development tools yet. The Nix flake actually helps here by eliminating some tool configs that would otherwise live in the project root, but you can still see how quickly things accumulate.

Some of those files just aren’t important enough to deserve top billing in my project repo.

Solving Directories for Projects Link to heading

There are several different proposals for project organization, but they mostly take the same obvious route: apply the XDG recommendations (or a subset) to project repos and the tools designed to work with them.

dot-config is, as far as I’m aware, the most popular effort in this space even though it’s still only a ~50 star GitHub project. They focus on pushing for tools to support config files in a .config/ directory. That would solve many of these issues, but doesn’t solve the whole problem.

PRJ Spec Link to heading

The PRJ spec is far more complete.

The PRJ spec takes a different approach than dot-config. Instead of just focusing on configuration files, it defines a comprehensive set of conventions for project-centric tools:

Project Root Detection: Tools should use $PRJ_ROOT environment variable, or implement their own heuristics (like looking for .config folders)
Configuration Home: Tool configs go in $PRJ_ROOT/.config/ instead of scattered across the project root
Cache Management: Build caches and intermediate files go in either $PRJ_ROOT/.cache/ or shared in $XDG_CACHE_HOME/prj/$PRJ_ID if projects have unique IDs

The philosophy is that project-centric tools (linters, formatters, build systems) should follow the same organizational principles that XDG brought to user-centric tools. Instead of every tool inventing its own way to find the project root and scatter config files everywhere, they should follow consistent conventions.

Status Link to heading

Within a rounding error, no dev tools support these efforts. I’m still stuck installing config files into the root of my repos.

Personally, I try to follow PRJ spec principles when I have control over how to layout files in my project directories. Local scripting, testing, caching build artifacts for development or benchmarking, etc.

My cmprss tool for example has a test script that downloads example files into a PRJ-compliant cache directory instead of cluttering the project root.

I know it won’t actually be ‘fixed’ any time soon, but oh boy would it be nice.

Optimizing Naively

Sun, 01 Jun 2025 00:00:00 +0000

Back in the day I honed my optimization chops while working on Project Euler problems.

I was dumb and young, and most of the things I tried were pointless, but I did stumble on a technique that I have kept using in the nearly 2 decades since.

Write the slow version first Link to heading

Project Euler problems have the stated intention that all of the prompts should be solvable in less than a minute of computation time with the right algorithm. I don’t know if that’s true for all of them, especially the latest ones, but I took that as a challenge to try to optimize my solutions to fit within that window, or often to just optimize the solution as much as possible.

Usually it was simplest to write a naive solution that would be horrifically slow, with computation time in hours, days, or years. But that slow solution was obviously correct. It was short enough to read and understand pretty easily so I could be confident that is was correct.

This was helped and guided by Project Euler problems usually providing a “checkpoint” solution, an example output from a portion of the problem. For example, a question might be “how many primes are below 1,000,000?” and they’d give the answer for primes below 1,000 so that you could check your algorithm on a smaller input.

What I would often do is write an “obviously correct” solution that solved the example, then do two things:

Start the slow solution running on the full answer. Sometimes this was fast enough.
Write a new version that was actually fast.

While writing the fast version I still had access to the slow version for unit testing and comparison, which was immensely useful for further work.

A recent example Link to heading

A few months ago I got nerd-sniped by a slight variation of this LeetCode problem: Find Median from Data Stream

For a stream of numbers, at each new input print out the XX%-tile number from the already seen inputs.

This problem has an obviously correct solution: you just take all the inputs seen, sort them at every step, and print out the XX percentile. It’s extremely slow, O(N * N log N), but is clearly correct. I placed that obviously correct solution into my unit tests.

fn calculate_percentile<T: Clone>(values: &[T], percentile: usize) -> T {
    let index = (values.len() * percentile) / 100;
    values[index].clone()
}

/// Test helper that inserts a sequence of values into a PercentileTracker and
/// verifies that the calculated percentile matches the expected value at each step.
///
/// # Parameters
/// * `values` - A slice of values to insert
/// * `percentile` - The percentile to track (0-100)
fn insert_and_verify<T>(values: &[T], percentile: usize)
where
    T: Clone + Ord + Debug + PartialEq,
{
    let mut tracker = PercentileTracker::new(percentile);
    let mut test_values = Vec::new();
    for value in values {
        tracker.insert(value.clone());
        test_values.push(value.clone());
        test_values.sort_unstable();
        let expected = calculate_percentile(&test_values, percentile);
        assert_eq!(
            tracker.get_percentile(),
            expected,
            "Failed at insertion {:?}",
            value
        );
    }
}

Performance Results Link to heading

The “classic” solution to this that interviewers look for is using Priority Queues, one for each “side”. These have operations on the order of O(log N), so inserting a full stream of inputs is O(N log N). They usually have poor memory locality characteristics though, so they end up being relatively slow for inputs that don’t fit into CPU cache.

I wrote a more general, O(N) solution for this problem using a bucketing strategy that I named PercentileTracker. You can view my code and more details in the repo https://github.com/arcuru/lib/tree/main/percentiletracker

PercentileTracker is relatively fast, and is able to process ~40 million inputs per second even at input sizes that don’t fit in CPU cache. Here is the estimated time taken to process 400 million 64-bit ints as input, while also outputting the 50th percentile entry at every step.

(Bench run using criterion on a Ryzen 9 7900)

With 64-bit input integers, this is an effective throughput of over 300 MB/s. For comparison, the naive approach of sorting the entire dataset at every step would take several hours for this same workload. I’m sure I could tweak the optimized version to get more performance out of it but I’m happy stopping here for now. The focus was on testing out the dynamic bucketing solution rather than micro-optimizations, and I certainly had fun doing that.

Benefits Link to heading

With an obviously correct solution you can write test cases extremely easily. It is not a replacement for unit testing edge cases, but it lets you find edge cases in your algorithm.

An obviously correct solution has several useful benefits while working on an optimized version:

Reference solution for testing edge cases. Run your unit tests against both versions and confirm that they both have the behavior you want. The clarity of the simple solution makes it easy to ensure you have the correct algorithm and edge case behavior.
Enables “fuzz testing” of a solution to find edge cases non-deterministically. Generate valid inputs randomly, feed them to both solutions, and look for differences.
It can serve as documentation. A naive solution can help a future reader of the code understand the problem in more depth.

For example, my PercentileTracker code was unit tested against the obviously correct solution during development. It helped catch some off-by-one errors, and helped find some test cases that I hadn’t considered when writing the code. It also gave me confidence that my code worked at different input percentages and sizes without having to manually code and define edge cases.

It also lets me run more comprehensive tests against small values for pretty cheap:

#[test]
fn test_large_dataset() {
    // Use a seed to make the test deterministic
    let mut rng = ChaCha8Rng::seed_from_u64(42);
    let values = {
        let mut v = Vec::new();
        // Insert enough values to trigger bucket splitting
        for _ in 0..(MAX_BUCKET_SIZE * 4) {
            v.push(rng.random::<i64>());
        }
        v
    };
    // Test at multiple percentiles
    for percentile in [1, 10, 20, 30, 40, 50, 60, 70, 80, 90, 95, 99] {
        insert_and_verify(&values, percentile);
    }
}

Honestly, it just gives me peace of mind that the faster version works without issue. Trading a little extra compute time for safer development and more correctness is a choice I’ll make every time.

Conclusion Link to heading

Writing and using the naive solution is a powerful tool for writing optimized algorithms. Having access to a slow but provably correct solution allows for verification of much more complex code without all the headache of formal proofs.

Don't Sleep on BitNet

Tue, 13 May 2025 00:00:00 +0000

EDIT: Apparently I’m not alone in feeling this way, here’s a post from the same day I posted this: All LLMs Will Be Sparse BitNet Hybrids

I took a break from working on my decentralized DB to dive into the latest LLM research. As usual, I focused on opportunities for optimizations and performance improvements.

This post is mainly a summary of my private notes I made while ‘researching’.

I’ve only looked at inference (generating output, i.e. actually using the models) as that should dominate the total compute cost, and it’s what needs to be efficient for local-first computing.

I read through a lot of techniques, but by far the technique with the most potential seems to be BitNet.

BitNet uses ternary weights with the values of [-1, 0, 1], which gives it extremely appealing performance characteristics.

I. An Overview of LLM Architecture Link to heading

Before diving into optimization techniques, let me briefly explain where all the computation goes. At a simplified level an LLM consists of:

Weights: Parameters learned during training (the actual “knowledge”)
Activations: Intermediate values computed during text generation
Layers: Stacked transformations, each applying specific operations
KV Cache: Storage for already-processed tokens (grows with context length)

When generating text, the model processes input through these layers, with the primary computational workhorses being:

Matrix Multiplications (MatMuls): These dominate compute time. Modern GPUs are built specifically to parallelize these operations, but they’re still expensive.
Memory Bandwidth: Moving gigabytes of weight data between memory and computation units is often slower than the computation itself.
KV Cache Growth: As context length increases, the memory needed to store intermediate states grows dramatically. This is why longer chats with LLMs consume far more RAM.

These bottlenecks become acute when trying to run models locally rather than in data centers. Cloud providers can throw specialized hardware and custom chips at the problem. Your laptop… cannot.

Model sizes Link to heading

Taking a step back, I should point out how LLM sizing will likely end up working in the long run. These are just my assumptions based on the hardware realities of today.

For practical deployment you can think of models in a few different tiers, each with very distinct capabilities:

Always-on assistant models:
- Sub-8B parameters, heavily quantized to fit in RAM or on accelerators. Useful for simple interactions and tasks, and can hand off to more capable models as needed.
Local Specialist models:
- 12-30B parameters with special training. You’d run the largest models you can locally for specialized tasks, capable of more autonomy. “Label all my photos with descriptions”, “Research a trip to Cleveland that I would like”.
Cloud fallback:
- Full-precision 70B+ models for the hardest tasks. Almost everyone will access these models remotely.

The optimal sizes will depend on hardware constraints, but even modest laptops can run Local Specialist Models at acceptable speeds with aggressive quantization. BitNet would give that extra push of potentially doubling the parameter sizes that could be run locally, and would significantly improve the inference speed at the same time.

At small sizes (1B-30B), like the ones most people will interact with frequently, doubling the number of params is a significant increase in capabilities. An 8B model is much more capable than a 4B model.

II. Existing Efficiency Hacks Link to heading

Several approaches aim to address these challenges with big efficiency wins, these are all in use in various forms today:

Quantization Techniques Link to heading

Quantization reduces the precision of model weights and activations. While 8-bit and 4-bit quantization are now standard practice, research is pushing toward even more extreme compression:

Traditional quantization (8-bit, 4-bit): 4-bit weights often have very little performance degradation and are quite common in local inference today.
Extreme quantization (2-bit and below): The current focus of several research groups.

The ParetoQ paper (arXiv:2502.02631) found something particularly interesting: 1.58-bit (3 values that vary per layer) or 2-bit (4 values, varying per layer) quantization may represent an optimal balance between compression and capability. For a fixed compute budget, you’re often better off running a larger model at lower precision than a smaller model at higher precision.

To get the most out of it though, you need to further finetune the quantized model to regain as much performance as possible after quantization. They show that it’s possible to regain a lot of the capabilities ’lost’ when quantizing by finetuning on 10-30 Billion additional tokens after the quantization.

This is a very promising approach, suggesting that post-quantization finetuning may be worthwhile for miniaturizing an existing model.

Note that this is not the same thing as BitNet. The 1.58-bit quants talked about in ParetoQ are of variable values, not the [-1, 0, 1] used by BitNet.

Mixture of Experts (MoE) Architectures Link to heading

MoE models take a fundamentally different approach to scaling. Instead of activating all parameters for every token, they contain specialized “expert” networks that are selectively activated:

Only a small fraction of the model’s total parameters process each token
This allows models to grow in parameter count without proportional compute increases
For example, Qwen 3 has a model that is 30B total parameters with only 3B active to compute each token.

You get some of the benefit of the full parameter count while only doing computation on a small fraction of it per token. The downside is that you need more memory to keep all the weights loaded.

Faster inference, but higher memory than an equivalently capable ‘dense’ model.

Many of the largest open weight models do this because they are more efficient to train compared to a dense model of similar capability, and it’s rumored that the proprietary models are probably MoE.

Speculative Decoding Link to heading

This approach uses a smaller, faster model to pre-generate likely outputs, which the larger model then verifies rather than generating from scratch. Google’s Speculative Decoding paper (arXiv:2211.17192) demonstrated speedups of 2-5x using this technique.

It can also be built into the model itself, as in Xiaomi’s MiMo and I’m sure many others.

III. BitNet b1.58 Link to heading

In my opinion, the most promising approach that should be pursued further is BitNet. The model sizes are similar to extreme quantization, but it allows for a fundamental change to the underlying math that meshes extremely well with the hardware realities.

What is BitNet b1.58? Link to heading

BitNet represents weights using only three possible values: -1, 0, and 1. This is called ternary quantization, using approximately 1.58 bits per parameter (log₂(3) ≈ 1.58). Unlike traditional quantization that starts with a full-precision model and then compresses it, BitNet models are trained from scratch with these constraints.

(Important note: this 1.58-bit is not the same as in ParetoQ. ParetoQ used values other than [-1, 0, 1] that change per layer.)

Why It’s Cool Link to heading

BitNet’s approach offers several advantages:

MatMul Becomes Addition: When weights are limited to -1, 0, and 1, multiplication operations are replaced with much simpler operations:
- Multiplying by 0: Result is 0 (skip the operation)
- Multiplying by 1: Result is unchanged (just copy the value)
- Multiplying by -1: Result is negated (single-cycle operation)
On modern CPUs, multiplication operations typically take multiple cycles, while additions and negations take just one. They also require significantly more die space and power.
Tiny Memory Footprint: Representing weights with just 1.58 bits matches even the smallest quants, allowing much larger models to fit in limited memory.
Hardware Acceleration Potential: The simplicity of BitNet’s operations makes it ideal for specialized hardware acceleration.

BitNet v2 Link to heading

The BitNet researchers recently published a follow-up paper (arXiv:2504.18415) introducing BitNet v2, which combines 1.58-bit weights with 4-bit activations and a technique called Hadamard transformation. This approach takes advantage of recent hardware support for 4-bit math while maintaining the core benefits of the BitNet approach.

It uses 4-bit math for Activations inside the model instead of 8-bit math, but the inputs are still the same size (8 bits).

In short, by switching to using 4-bit Activations with the same size model they can:

Keep the same size on disk
~Halve the size of the KV Cache, decreasing how much memory is used by the context
Use INT4 operations, potentially doubling the theoretical computational throughput

Initial results show these extremely compressed models can achieve performance comparable to BitNet b1.58, which itself is similar to the performance of models with larger quant sizes and the same parameter count.

I’ll repeat that last point, they are claiming comparable performance to models that are twice the size in RAM, and they’re doing it while also getting rid of the multiplies.

IV. So What? Link to heading

A BitNet model with an optimized library to run it should be extremely efficient even for CPU inference, here is a chart from the BitNet repo showing inference tokens/second on ‘dummy’ models of different sizes.

Keep in mind that they are also claiming that they also achieve similar performance to existing models of the same size. Those numbers are significantly higher than what you’d get for similar sized models using CPU inference.

Those claimed numbers are roughly comparable to running existing models on my not very small GPU.

Synergy with MoE Architectures Link to heading

BitNet and MoE architectures complement each other beautifully. If BitNet allows us to significantly reduce the memory footprint of weights, we could:

Fit much larger models in the same memory
Increase the number of experts in an MoE model without increasing memory requirements
Deploy sophisticated models on devices that previously couldn’t support them

This synergy could be particularly powerful for local computing, where memory is often the primary constraint.

Qwen 3’s largest model is a 235B parameter model with 22B active parameters. A BitNet v2 model of that size would only be ~80 GB and would be runnable at ~5-10 tokens / second on a high-end Desktop, without offloading to the GPU.

The Efficiency Frontier Link to heading

When evaluating model performance, we need to consider not just raw accuracy but efficiency. The relevant question isn’t “How does a 2-bit model compare to a full-precision model?” but rather “How does a larger 2-bit model compare to a smaller full-precision model when both use the same amount of computation or memory?”

Most of the literature compares against models of a similar parameter size because that is normally a good proxy for performance and memory requirements, but that falls apart for BitNet.

There’s somewhat limited data comparing like-for-like models computationally, which I find really odd. If BitNet can scale, it seems like it would be significantly more efficient when comparing to models of similar performance.

It’s Not Ready (yet) Link to heading

While BitNet can run on existing hardware, its full potential will come through specialized chips:

Software implementations on current hardware (modest gains)
Optimized implementations leveraging existing hardware features (significant gains)
Custom accelerators designed specifically for BitNet-style operations (transformative gains)

The simplicity of BitNet operations makes it an ideal candidate for custom silicon that could achieve orders of magnitude better efficiency than general-purpose processors, though writing optimized CUDA kernels to take advantage of the INT4 math on the latest NVIDIA GPUs would still be impressive perf wise.

V. Open Research Questions Link to heading

Several important challenges remain:

Training efficiency: Training BitNet models from scratch is computationally expensive, but it seems like the ternary models may require it. I couldn’t find research on trying to quantize a larger model to [-1, 0, 1] weights, but maybe someone will find a usable technique. Regardless, even if it’s more expensive to train, it’s significantly more efficient in inference so the total compute over its lifetime should be smaller.
Capability retention: More research is needed to understand which capabilities are preserved and which degrade as you scale up the training and parameter size.
Hardware/software co-design: The full potential of BitNet will only be realized through tight integration between hardware and software design.

Conclusion Link to heading

BitNet’s 1.58-bit approach represents one of the most promising paths toward dramatically more efficient LLMs. I’m shocked there doesn’t seem to be more work going into it given its potential.

I don’t have the money, but I’m intrigued by the idea of training a decent sized model (14B-32B range) to better test how it performs. The BitNet team has been doing research on small models up to 2B parameters, so it remains to be seen if the capabilities scale as well as higher quant models, and proving capabilities in a 32B model would be a really strong proof of concept.

References Link to heading

Microsoft BitNet
- BitNet v1: arXiv:2402.17764
- BitNet v2: arXiv:2504.18415
ParetoQ: arXiv:2502.02631

You're Holding AI Wrong

Fri, 04 Apr 2025 00:00:00 +0000

If you’re old enough you may remember “Antennagate” from 2010, when iPhone users were told they should avoid gripping the phone in certain ways. The phrase “you’re holding it wrong” became shorthand for blaming users instead of fixing bad design.

Apple, of course, was trying to blame users instead of admitting their own problems.

But here’s the thing: sometimes it really is the users who are holding it wrong. And that’s exactly what I’m seeing with the current crop of generative AI tools.

The Problem with How We Use AI Link to heading

I see a lot of people using generative AI wrong. Some treat it like Google, expecting perfect factual answers. Others approach it like an all-knowing oracle that will solve their problems with minimal input. And then there are those who seem to only want to find its faults, poking and prodding until they get hallucinations they can screenshot and mock online.

It’s none of those things. Yes, it may be just very fancy autocomplete, but it’s more than that too. It takes a while of using these tools to get a good feel for them but it’s becoming increasingly clear that this tech will fundamentally change how we interact with the world. It’s best to be prepared.

I’ve used these tools extensively for coding, and I wanted to explain to my non-coding friends how to use them properly.

Fundamentally what most people don’t understand is that this crop of AI should be treated as tools, not as full solutions.

Writing a Blog Post: The AI-Augmented Way Link to heading

To try to be as broad as possible, let’s walk through the process for writing a blog post with AI assistance:

You come up with an idea for a post. This is critical. The AI doesn’t decide what you want to write about—you do. The initial creative spark still comes from you
Write personal notes on your direction. Jot down your key points, the tone you want to strike, and any specific angles you want to cover. These notes will guide both you and the AI throughout the process.
If needed, gather supporting information. Use search tools like Google or Perplexity to gather research and references. I’d recommend sending well-formed questions to the various “Deep Research” tools. Perplexity, OpenAI, and Google all have one. They iteratively search and research a topic for you, potentially saving time while researching and collating the data.
Summarize your research. Take that data and strip it down to only the important bits needed to have a full understanding of the context for the post. This step helps you organize your thoughts, come to your own conclusions, and decide what makes sense to include, drop, or save for later.
Generate multiple drafts. Send the resulting collection of notes, outlines, and research to multiple LLMs and instruct them to write a draft. Different models “write” differently, so your favorite may vary. If you want to get fancy, include example blog posts you’ve already written and say “do it like this.”
Provide feedback and iterate. Give clear feedback to the LLMs if you want them to adjust. This is where you shape the output to match your vision, not just accept whatever it spits out.
Synthesize the final product yourself. Gather the best 2-3 drafts, and from those, write the actual blog post. Take what you like, toss what you don’t. Maybe go back and have the models rewrite specific sections that aren’t quite right.
Repeat steps 5-7 as desired. Generate drafts, edit, refine, until you’re done.

In this new paradigm, words are abundant. What’s scarce is your perspective, creativity, and expertise. Generative AI can’t replace that. What it can do is amplify your abilities, save you time, and help you explore ideas in ways you might not have considered on your own.

So, if you’re treating AI like a search engine or expecting it to do all the work, you’re holding it wrong. Think of it as a collaborator—a tool that requires practice, patience, and a clear sense of direction.

The best way to get better? Just try it.

Extra Credit Link to heading

If you’re a bit more technical, there’s a powerful trick you can borrow from software development: use a version control system like git to track your drafts.

Think of it as a time machine for your writing. Every time you make a change, you can save a snapshot. Later, you can see exactly what you added, removed, or rephrased—line by line. This makes it much easier to experiment, knowing you can always roll back or compare different versions.

You can even branch off multiple directions—try a more casual tone on one branch, a more formal style on another—and then merge the best parts together. It’s a great way to iterate quickly without losing anything along the way.

It might sound complicated, but even basic use of git can supercharge your editing process. And if you’re collaborating with others it’s invaluable for managing feedback and revisions.

Treat your drafts like code: version early, version often.

The Human Element Is Essential Link to heading

What you bring, as the human, is expertise and judgment. You guide things toward what you want the output to be. You toss things you don’t like. You give these tools feedback and steer them toward your vision rather than accepting whatever they produce.

The AI doesn’t replace you—it amplifies you. It gives you a massive boost in productivity and capabilities, but only if you’re holding it right.

Personally I get a lot of value out of using them to remove things that are often roadblocks for me. I can take notes and generate a blog post directly from the raw notes. I don’t need to spend an hour fixing up grammar or thinking through different clever phrases, I can just use these new tools to fix that. I can focus my attention on the bigger things.

These tools can take work to understand. My main suggestion is that you try them occasionally to see if you can fit them into your workflow. Go to openrouter.ai to access any model, not just one from a single company. Sometimes you’ll find that you prefer the “voice” of different models for different types of tasks.

Some will be better at technical writing, others at creative work, and still others at summarization or research. Finding the right tool for each job is part of the process.

Conclusion Link to heading

We’re in the early days of this technology, and most people are still figuring out how to use it effectively. Take the time to learn how these tools actually work and how to get the most out of them.

And yes, of course this post is a description of how I wrote this post. I also used it to help write some of my previous post Base 10 Was a Mistake. I’m not sure I like how they came out though, it’s a little difficult to get the tone and flow to sound natural. I ended up cutting/editing quite a bit and the end result is still a little bit wordy overall.

Base 10 was a mistake

Thu, 27 Mar 2025 00:00:00 +0000

I’m stepping onto my mild OCD soapbox today. But I needed to get this out there.

Base 10 was a mistake. I want to curse the evolutionary gods for giving us 10 fingers instead of 12.

The Problem with Base 10 Link to heading

Our decimal number system is built on an accident of human anatomy. We have ten fingers, so we count in base 10. That’s it—that’s the entire reason. We’ve built our entire mathematical system on “well, I ran out of fingers to count on.”

And you know what? That’s actually kind of terrible. Base 10 gives us exactly three factors to work with: 1, 2, and 5. That’s why we spend so much time dealing with repeating decimals and awkward fractions. Want to divide something into thirds? Hope you like writing 0.33333… forever. Want to split something into quarters? 0.25 isn’t terrible, but it’s not great either.

Why Base 12 Is Better Link to heading

Base 12, on the other hand, is much better. It has twice as many factors: 1, 2, 3, 4, 6, and 12. This means more numbers divide evenly, which makes mental math easier and decimals cleaner.

Let’s look at some common fractions:

1/3 in base 10: 0.333333…
1/3 in base 12: 0.4 (clean and done)
1/4 in base 10: 0.25
1/4 in base 12: 0.3 (even cleaner)

We actually still use base 12 thinking in a lot of places:

12 months in a year
12 hours on a clock face
12 inches in a foot
12 units in a dozen

You know why? Because it’s genuinely more practical for everyday use.

The Real-World Impact Link to heading

I can already hear you saying “who cares about clean fractions?” Well, anyone who’s ever:

Split a restaurant bill three ways
Tried to divide their time evenly between projects
Needed to calculate percentages in their head
Worked with measurements in construction
Done any kind of financial calculations

So… basically everyone.

Why We’re Stuck With Base 10 Link to heading

The problem is, switching to base 12 would be an absolute nightmare. We’d need to:

Retrain literally everyone in mathematics
Replace every numeric display ever made
Update all our software (I can already hear the COBOL maintainers screaming)
Convince people that “10” means twelve now
Probably rename all the numbers to avoid confusion

And that’s just the start.

The “right” solution would be to slowly transition to base 12 over several generations. Start teaching it in schools alongside base 10, begin using it in scientific contexts, and gradually phase it in as the old system phases out.

But that’s never going to happen. We’re stuck with our ten-fingered counting system forever, watching our calculators spit out endless repeating decimals because our ancient ancestors couldn’t think past their hands.

Conclusion Link to heading

Base 12 is better than base 10 in almost every way that matters for real world use. It’s more practical, more divisible, and would make everyone’s lives easier if we used it. But we won’t, because sometimes the cost of fixing a suboptimal system is higher than the cost of living with it.

Kind of like that legacy codebase you’re maintaining that really needs to be rewritten but “works fine” so it’ll never get approved. You know the one.

Maybe I’ll go join the Dozenal Society of America to help spread the good word.

Generative AI and Copyright

Sat, 22 Feb 2025 00:00:00 +0000

Disclaimer: I am a Software Engineer. I am not an Economist, nor am I a Lawyer, and even I know that this isn’t as simple as it sounds.

TL;DR - I’m proposing that we allow copyrighted material to be used for training AI models, and in return we should institute a new tax on the profits from those AIs.

The current crop of AI models are not possible without utilizing large amounts of copyrighted material in their training.

Meta has already been caught torrenting 80TB of books to use for training. It’s safe to assume that their Llama models have been trained on every book and scientific paper ever written.

And if you think the other companies did not do the same thing, you are naive. Model performance heavily relies on the size and quality of the training data, it is generally accepted that all the leading models were trained on copyrighted material.

Legally acquiring the rights to all of that data would be prohibitively expensive. Maybe Microsoft or Meta or Google could actually afford to pay for all the copyrighted material ever created, but startups certainly couldn’t.

What we as a society should want out of this technology is for it to be democratized. We should celebrate startups and individuals building their own AI models, we want as many people as possible to be able to compete and innovate in this new landscape.

However we also need to recognize that those innovations are only possible because of the immense amount of human ingenuity and effort that has gone into creating copyrighted works. It is high quality data that the AI’s can learn from, and it is valuable. But it’s almost impossible to point to a specific copyrighted work as more valuable than the rest.

So I have a proposal, let’s put all the AI companies on a payment plan.

You should be allowed to train an AI on all copyrighted material, with caveats.
We should tax the fuck out of any profits from the resulting AI and use it for the public good.

In effect, I’m proposing that we declare aggregated copyrighted works a public good. They are the product of humanity, and should be used for the benefit of all people.

This would provide a funding source for those displaced by AI jobs, and ensure that companies located in countries with strict copyright laws can legally compete with their competitors that operate in countries without such restrictions.

Japan already has laws on the books that allow the use of copyright materials for training AI models, let’s extend that to also embrace taxing them for the public good.

Why I Switched from Cody to Continue.dev

Wed, 18 Dec 2024 00:00:00 +0000

An AI assistant has become an invaluable part of my development workflow over the past year, especially over the last several months. I started with Copilot, switched to Cody for a few months, and am now using Continue.dev.

I was really happy using Cody (made by Sourcegraph), and was happily recommending it to friends, so I wanted to lay out why I stopped using them and switched to Continue.dev.

Background on AI Assistants Link to heading

If you aren’t familiar with AI assistants, they are frontends to usually the same underlying LLMs.

They may use different models for various components, run some things locally or remotely, etc., but they more or less have access to the same backend models.

AI assistants bring two distinct pieces of value:

User experience, by integrating into your coding workflow.
Smart usage of context to feed to the underlying models.

The second part is very important in how useful any queries to the LLMs can be. It’s all about getting the right context for any given query.

When you ask a question or want autocompletion, the model needs to be fed some subset of your codebase or docs to give the best response. Knowing exactly what context to provide is a pretty difficult problem, as you need a good understanding of the codebase to know which parts are actually relevant to any query.

Sourcegraph’s entire business is in understanding and searching codebases. They should have a huge advantage in gathering the right context for queries.

I can work around UX issues, but I am willing to pay real money for a perceivable improvement in LLM answer quality, and Sourcegraph is best positioned to do that.

And until I hit this particularly problematic bug, I was an extremely happy customer.

The Problem Link to heading

My Bug Report Link to heading

Cody would consistently refuse to answer questions in two of my repositories when allowing it to choose context from the codebases. After hitting this issue multiple times, I reached out to their support team to understand what was happening.

The errors were essentially, “Your request was blocked, here’s an ID to use with customer service.”

All customer service could tell me about my specific request was that it contained the word “Reset”, which caused the request to be blocked.

Here was my response, which I think sums up the situation well, so I am including it as is:

Thank you for the information. With that I was able to find the problem, though I would suggest that this is forwarded to your development team for triage.

Cody is including context from the Changelog file. In both repos, the changelog file contains the line “- Add a clear command to reset the session”.

Removing that line allows the request to go through.

I would suggest that Cody is updated to handle that situation more elegantly, as Cody is the one that decided to include that line as context. I was not even directly asking a question about the Changelog file.

The infringing lines that break requests for these repos:

https://github.com/arcuru/chaz/blob/58c20aa736f9a71ae6e8237809643fc63de92f40/CHANGELOG.md?plain=1#L20

https://github.com/arcuru/headjack/blob/f04922d79c7586cc5e99870e7d45d8ee387b0768/CHANGELOG.md?plain=1#L48

I’m…not going to edit my auto-generated Changelog so that I can use Cody in those repos, and there seems to be no way for me to otherwise fix this on my side without maintaining a local diff to that file.

Thanks for the help :)

It doesn’t actually matter, but I do have some guesses as to why the word “Reset” was actually blocked that I included down below.

No Workarounds Exist… Unless You Pay for Enterprise Link to heading

The only way I could fix this would be to include context filtering into Cody, to tell it, “Hey, never include the changelog file.” This is not ideal. What if I used the phrase “reset the session” in a code comment too?

But even then, Cody doesn’t make that very easy.

Cody apparently did have a way to filter individual files like that, but IIRC it was always behind an ’experimental flag’ and is now restricted to their Enterprise plan.

Which, like, come on, that’s a crazy thing to put behind a paywall.

Continue just has a .continueignore file that works exactly like .gitignore.

It’s Just a Bug. Why Leave? Link to heading

Yes, and it’s fixable, but:

I was only using Cody for finding the right context. They had one job.
Apparently, they try to block the word “reset” (or more likely “reset the session”, see below). I use that word occasionally, and banning the word “reset” is insane.
Their context filtering is apparently so bad that it doesn’t filter out context that they themselves block.

I literally paid them to do a single job for me, and they were so bad at it that they didn’t take into account their own requirements.

The Solution Link to heading

I switched to Continue.dev. In the spirit of all good OSS projects, they have worse UX but are way more configurable. I want to pay them to improve their UX, but it’s free (bring your own keys) and I haven’t figured out where I can give them money.

I use a mix of a local LLM for autocompletion and bring my own API keys to use my preferred chat/embed/re-ranking remote models. For some weird reason (ahem… money), you have to buy the Enterprise plan from Cody to bring your own API keys (which actually would save Sourcegraph money, as you’d be paying Sourcegraph just to be a plugin and would also be paying a different provider for the actual models).

I also highly recommend that everyone using an assistant should go through Continue.dev’s documentation and configure it. It was fantastic for helping me understand what each of the AI assistant components actually do. Even if you use something else, it can be really helpful. Links to the User Guide and the instructions to Customize the plugin.

Appendix Link to heading

Why Does Cody Hate “Reset”? Link to heading

So, this is their full explanation:

Checking the reference ID you provided, the request seems to have been blocked because it included the word or phrase “Reset,” which our system flagged. For your privacy, I am unfortunately not able to see the full prompt, so I can’t verify exactly what you sent, but I suggest you check the contents of your prompt.

This is just a precaution to avoid any potentially harmful actions. The prompt_prefix I shared above gives us a glimpse of the user’s input and the code referenced, which may have triggered the block.

I’m guessing they actually block “reset the session” or a similar intent, not just the word “Reset.”

What they’re probably blocking is an attempt to steal the full prompt of the request. Basically, if you managed to “reset the session,” you could figure out what Cody was including as instructions or as context. The only reason to block such a thing would be to protect their business in some way, as knowing what the prompt contains can be used to compete with them.

So yes, I was kind of annoyed that Cody’s one job was to include good context, and it included context that broke its own filtering to protect itself.

ChaZ: Chaz haz a Zervice

Sat, 26 Oct 2024 00:00:00 +0000

You’ve heard of SaaS and IaaS, so I wanted to get in on that.

But, you know, not make any money from it.

Background: What is Chaz? Link to heading

I already announced Chaz, but now I’ve made ChaZ.

Chaz is my Matrix bot that hooks your chats up to the LLM of your choice. Chaz hooks up your normal Matrix client with the LLMs, you can even add images into the conversation if the backend supports it.

I hated the fact that all those cute little VC-funded startups were stupidly making their own clients, so I wrote a little bot that competes with them.

Introducing ChaZ Link to heading

Chaz haz a Zervice now.

I added the ability to setup your own API keys while talking to Chaz, so this lets me run a bot account that anyone can use.

The API keys are stored inside Matrix room tags. Those are only accessible to the account that sets them, in this case the Chaz bot.

It means that anyone running the Chaz bot can access them, but they don’t have to worry about storing anything other than login info locally. Matrix, and the homeserver being used, stores the data itself.

But Why? Link to heading

I realize that a small percentage of people aren’t in the habit of running their own services. (/s!)

By offering to host it myself, I can allow users who don’t have a selfhosted homelab to use this.

How do I use it? Link to heading

The full info about how to use it is in the Chaz README.

In brief though, you just add the Chaz account to the room of your choosing and interact using !chaz commands. Send !chaz help to get a list of options.

The user interaction is not that mature, but if you have suggestions for improvements please file an issue in the repo.

Can I use it with groups? Link to heading

Yes!

Chaz should work …ok… for a group context, but it definitely needs more testing and refinement.

When adding your own API keys for a group, you should probably send the command to Chaz, !chaz backend <name> <url> <api key>, and once Chaz acks the setup you can delete the message with that data in it. Users in the group will still be able to use the API key through Chaz, but won’t have access to the API key themselves.

I don’t trust you Link to heading

Ok, then don’t use ChaZ, just run your own? I can’t see a way where you could bring your own API keys without trusting the bot owner with access to the keys.

What’s the bot’s name again? Link to heading

@chaz:jackson.dev

Pok'em: Seamless Notifications with Matrix

Fri, 25 Oct 2024 00:00:00 +0000

# These three commands are all equivalent
pokem !RoomID:jackson.dev Backup failed!
pokem --room !RoomID:jackson.dev Backup failed!
curl --fail -d "Backup failed!" pokem.dev/!RoomID:jackson.dev

pokem Backup failed! # Will send to your configured default room
pokem error Backup failed! # Will send to your configured room named "error"
pokem --room error Backup failed! # Same as above

# It also accepts stdin as the room message
echo "Backup failed!" | pokem error # Sends to the room named "error"
cat README.md | pokem # Send the contents of a file to the default room

# Authentication
# Inside Matrix, you can set a pokempassword using the bot interface.
# If you do that, you won't be pinged at 3am by some rando, because even if
# They can guess your roomid, they'll still need to include the password like so:
curl --fail pokem.dev/roomid -d "poke the room" -H "Authentication: pokempassword"
pokem --auth pokempassword --room roomid poke the room

While writing Chaz and headjack, I realized that it would be pretty easy to build a self-hosted alternative to ntfy…

So anyways, that led to building Pok’em (“Poke Them”)

Pok’em is a Matrix bot, that listens to HTTP requests, and from there pings a Matrix room. It’s available as a CLI app to send the notifications, but you can also just use curl

The goal here was just to build something super easy to self-host, while still keeping many of the design elements of ntfy. It supports some ntfy features, but only important ones…like emoji support.

If you don’t want to self-host, I also run a hosted bot @pokem:jackson.dev, its public interface is on pokem.dev

Key Features Link to heading

I added more features than necessary probably:

Command Line and HTTP Interface: You can notify a Matrix room directly from the Pok’em CLI, or with HTTP using PUT/POST requests. So it’s easy to integrate in CI or from anywhere.
No Service Needed: The Pok’em CLI tool can be used by itself without a server. As long as it has the Matrix login info it will log in and send the notification itself, no Pok’em server necessary.
GUI Interface: When viewing with a browser, the service runs an HTTP site that takes in commands, see pokem.dev
Users Control Readers: Matrix has its own Encryption and access controls. You invite the bot to your room, and you can control who gets access to that room.
Users Control Writers: You can set authentication keys on each room, requiring the sender to include the auth key. That controls who can send messages into your room, so you don’t get some rando pinging your on-call room at 3am.
Docker Support: It’s on Docker and has a tiny config file, but you also can just use my hosted pokem bot @pokem:jackson.dev.

If you want have questions, post on the repo or the public Matrix room: #pokem:jackson.dev.

Cloning Windows Recall in 30 Lines of Bash

Thu, 06 Jun 2024 00:00:00 +0000

June 6, 2024

This is mostly a demonstration of what Windows Recall actually seems to do under the hood, and is not meant to be seriously used.

Here’s the code, I have more to say after:

#!/usr/bin/env bash

if [ "$1" == "--daemon" ]; then
    MD5LAST=""
    while true; do
        # Use the current date and time for the screenshot filename
        FILE=~/recall/$(date +"%Y/%m/%d/%Y-%m-%d-%H:%M:%S")
        mkdir -p $(dirname $FILE)
        grim $FILE.png # Take a screenshot
        # If the screenshot is the same as the last one, disregard it
        MD5=$(md5sum $FILE.png | cut -d ' ' -f 1)
        if [ "$MD5" == "$MD5LAST" ]; then
            rm $FILE.png
            sleep 5
            continue
        fi
        MD5LAST=$MD5
        # Run tesseract on the file to extract text from the image
        # It always appends .txt to the filename, so the final name is $FILE.ocr.txt
        tesseract $FILE.png $FILE.ocr > /dev/null 2>&1 &
        sleep 5
    done
    exit 0
fi

# The arguments are assumed to be a ripgrep search query
FILES=$(rg --files-with-matches $@ ~/recall)
# Replace the filename extensions, which should be .ocr.txt, with .png
FILES=${FILES//.ocr.txt/.png}
mcomix $FILES

When called with --daemon it will handle the screenshotting/OCR analysis, and when called with anything else it is interpreted as a ripgrep search.

Note this has quite a few dependencies, including Wayland since it is using grim for screenshotting. I would package it up using A Portable Nix-shell Shebang if I wanted to distribute it.

Why? Link to heading

I admit that I actually like the idea of having Recall available, I just want it to be OSS.

I’ve been thinking about writing my own version of Recall that could run cross platform, sync between devices, and that I could have full control over outside the whims of Microsoft. I know that rem and xrem exist, but I would prefer to write my own greenfield project, and I struggled to get the xrem GUI to work anyways.

I would also want to take the project in a slightly different direction.

The sheer amount of information that this tool would ingest would make it a good starting point as a centralized “Search Everything I’ve Used” tool, which the other projects don’t seem to be doing, and I’m tempted to build. For example, giving direct access to index your email/chat/photos/directories/cmd history/etc would allow the tool to also search through every other organized piece of data, and place the screenshots into the right context.

Instead of starting a full blown Rust project like I usually do (see pokem, chaz, cmprss, etc) I wanted to experiment with the tech a bit by writing a simple script to outline what the basic functionality of this thing actually is.

So one short coding session later here we have it.

Of course this script is barely usable, but it will absolutely work for watching everything that appears on your screen and searching for text that appears.

Chaz: An LLM <-> Matrix Chatbot

Mon, 15 Apr 2024 00:00:00 +0000

Chaz is a Matrix bot that connects you to a large number of LLM models. It is a replacement for the Chat interfaces that you might be used to when working with LLMs.

Code repository

Instead of dealing with each company’s custom interfaces, this just moves your chats into Matrix with all the features of your favorite Matrix client.

(Chaz is written in Rust, and while building this I also built a very basic Matrix Bot Framework in Rust, headjack)

By plugging into Matrix, we get a few things for free:

Use any Matrix client you want, and any Matrix tooling since they are just Matrix chats.
Let anyone you want use it (there’s an allow_list). For example, run a bot yourself and share access to your API keys with your less technical friends. Or access to your internal company models/keys.
Share a chat session with anyone. Just add them into the Room.

Originally I wanted to allow users to use their own API keys, so you could run this as a simple service and just point people to it instead of making everyone run this themselves. There are obvious security implications with this though since whoever controlled the bot would have access to the keys, and I don’t want to deal with that now.

I have setup a demo account if you want to test it out a little, but long term this is something you’ll need to run yourself. You’ll only be able to send a few messages to the demo account, and you won’t be able to use it in large rooms. It’s also running a system prompt that is more for amusement than practicality.

The demo is @chaz-demo:jackson.dev

Why Link to heading

A few weeks ago I was trying to play with different LLMs. Running some locally with ollama or llamafile, using ChatGPT or Gemini, or other APIs like Together.ai or Groq. All of those have different interfaces, either custom made or only available over API.

But it’s just a Chat interface, and I have already been moving all of my chats into Matrix.

AIChat was the missing piece that tied it together for me. It’s a command line interface that lets you setup a lot of different backends and select them on the command line. Pushing ollama and ChatGPT into the same interface.

So I had an idea, it’d be easy to write a simple Matrix bot, with a mostly text interface, and use AIChat as the backend to unify everything into Matrix.

Why is it called Chaz? Link to heading

Several months ago I saw someone on Hackernews mention that they use a system prompt requesting that the models refer to themselves as Chaz in the 3rd person. I’ve been using it myself and I find it hilarious.

I think it was a reference to Chazzzzz from the show Disenchantment.

Results Link to heading

After a bit of work, I now have Chaz. It is pretty rough, but I already use it as a mostly fully capable replacement for the other interfaces. You can:

Send the chats to any backend setup in AIChat.
Send images to the image models.
Switch between backends in the middle of a session.
Rename the Room/Topic using a model.
Setup a role/system prompt to whatever you want.

It very quickly became a workable replacement for the Chat interfaces I had been using.

Matrix Bot Framework for Rust Link to heading

I wrote this in Rust but there doesn’t seem to exist a Matrix bot framework for Rust. So I ended up splitting out headjack into it’s own project.

It handles the bare minimum necessary to deal with the Matrix protocol with a lean towards helping write bots. A very simple bot could be written on top of headjack with minimal effort

Usage Link to heading

Chaz supports commands (currently everything prefixed with a ‘.’ to match AIChat, but that may change)

.help

Available commands:

- .print - Print the conversation
- .send - <message> - Send this message without context
- .model - <model> - Select the model to use
- .list - List available models
- .clear - Ignore all messages before this point
- .rename - Rename the room and set the topic based on the chat content
- .help - Show this message

Any message that isn’t a command causes the entire conversation (up to the last .clear command) to be send to AIChat for completion.

Future Link to heading

Here are some things I want to do with this, most of which just require some typing and not building anything novel:

Login as your own Matrix account to provide suggested responses to messages. (I’m not sure the cleanest way to setup that interface).
This one is definitely better when it’s builtin to your client, but we may be able to fake this one ok.
Ideally I’d want to be able to edit my drafts from the bot, but I don’t think Matrix syncs drafts.
e.g. Give it access to your own account, so you can ask Chaz “Help me draft a reply in room ‘Fizx Gang’, I want to explain XYZ”.
Possibly use the Room Topic to store the configuration, for display/editing of the settings.
Send to multiple backends in a single session.
Respond to Reactions (thumbs up/down/etc). Maybe by regenerating responses, selecting the response you want to continue with when using multiple backends, etc.
Support both sending and receiving files, to hookup to image generation backends.
Replace AIChat as the backend, as using that as the “API” is fairly limiting.
LLamafile support.
Support for changing the model settings from the chat. Temperature, Grammar, Tokens requested, etc.

NixOS Escape Hatch

Wed, 20 Mar 2024 00:00:00 +0000

March 20, 2024

I’ve used NixOS exclusively for several years now, and it’s occasionally useful to have an “escape hatch” into a different distro.

For certain tasks NixOS is more difficult than it needs to be, so being able to run a task in Ubuntu/Arch/etc has saved time by not having to deal with the Nix configs.

For example, I work with a lot of different software projects, and sometimes I want to use something that isn’t trivial to get setup in NixOS. Many projects will have build instructions for Ubuntu, and officially support building only on Ubuntu, and don’t yet have a nixpkgs package for NixOS.

In those cases figuring out the custom Nix shell environment can be a bit of a pain. And if I just want to jump in and fix a small bug it isn’t worth it to go through all that setup.

Enter Containers Link to heading

Instead of using docker, you can use the already builtin systemd-nspawn.

NixOS uses systemd as it’s init system, so it’s already installed and you just need to set it up. Systemd can manage a full container setup using systemd-nspawn and machinectl.

No installing docker if you don’t need it. No managing a docker-compose file. Just pull and install an image and you’re good.

Containers will be saved in /var/lib/machines

GUI Link to heading

It is possible to use GUI programs from inside the container. I don’t use them (yet), but it should be possible by setting the DISPLAY variable in the environment. See the docs on the Arch wiki for some pointers.

I will update this if I start using a GUI from the container.

Nix Config Link to heading

Here is the Nix code needed for an nspawn container named “ubuntu”. You should adapt this to any containers that you want to setup, feel free to make more than one. Before using this config you should setup the machine named ubuntu or you’ll run into some errors.

The code below bind mounts my code directory /home/patrick/code, since I use this environment for working with code projects that I don’t want to bother setting up in NixOS. You should adapt this to your system, and include whatever folders you want to share with the container.

If you want to see what any of the options do, look them up on NixOS Search

  systemd.targets.machines.enable = true;
  systemd.nspawn."ubuntu" = {
    enable = true;
    execConfig = {Boot = true;};

    filesConfig = {
      # Bind resolve.conf to get networking
      BindReadOnly = ["/etc/resolv.conf:/etc/resolv.conf"];
      # Bind any directories that you want to be shared
      Bind = ["/home/patrick/code"];
    };
    networkConfig = {Private = false;};
  };
  systemd.services."systemd-nspawn@ubuntu" = {
    enable = true;
    requiredBy = ["machines.target"];
    overrideStrategy = "asDropin";
  };

This sets up a systemd service that will manage the container and start at boot. Use the normal systemctl stop/start/restart commands to enable/disable the container service.

Installing Link to heading

To actually setup and use the machine, we’ll use nspawn.org. They host container images for several common distros which makes it very easy to get started. See their FAQ for their instructions, but the short version is that machinectl is what you should use for most everything.

NOTE: The command shown here pulls the image without verifying the signature. If you want to be extra cautious, follow the instructions on the nspawn FAQ to setup signature verification

> machinectl pull-tar https://hub.nspawn.org/storage/ubuntu/mantic/tar/image.tar.xz ubuntu --verify=no

Manage Link to heading

Using the machine is pretty easy. Start the container and then login with:

> machinectl start ubuntu
> machinectl login ubuntu

The default root login for the nspawn.org images is root/root.

machinectl has subcommands for stopping, deleting, or cloning the machine. I suggest you read through the options in machinectl --help.

One method you could use for it is to setup a base Ubuntu/Arch image and then clone it as needed for testing or specific projects. Or you could just have single long-running machines that you keep around.

With root access, I trust you can take it from here, so I won’t bore you with any more details.

A Portable Nix-shell Shebang

Tue, 07 Nov 2023 00:00:00 +0000

Updated May 21, 2025, with a better script example

All of my personal scripts with more than a few dependencies start with the Nix-shell shebang: #!/usr/bin/env nix-shell. Regardless of what language they are written in.

That only works if nix is installed, so it is difficult to share with others who may not use nix.

If I want the script to be shared with other people, I instead use something like this:

#!/usr/bin/env bash

# Check if we're already inside a nix-shell; if not, relaunch script inside nix-shell
if [ -z "$INSIDE_NIX_RANDOMSTRING" ] && command -v nix-shell &>/dev/null; then
  # Set environment variable to prevent infinite recursion
  export INSIDE_NIX_RANDOMSTRING=1

  # Launch the script within a nix-shell with required dependencies
  exec nix-shell --packages jq go --run "$0 $*"
fi

# Verify dependencies are available
go
jq --version

Or the flake version:

#! /usr/bin/env bash

if [ -z "$INSIDE_NIX_RANDOMSTRING" ] && command -v nix-shell &>/dev/null; then
  export INSIDE_NIX_RANDOMSTRING=1
  exec nix shell nixpkgs#jq nixpkgs#go --command "$0" "$@"
fi

go
jq --version

That snippet checks for the presence of nix-shell, and then reruns the script under nix-shell after installing the necessary dependencies. The -I argument is optional, and can be used to pin nixpkgs to a specific version (using a commit hash).

Portability Link to heading

For my personal scripts I just use the normal nix-shell shebang line, #!/usr/bin/env nix-shell, but I can do that because I am the only one that typically uses them, and I use NixOS. If you want to write scripts to share with others, adding Nix as a dependency isn’t always going to be a good idea.

Instead, what I do above is use it to install dependencies if it’s available. That way you can have all the non-Nix folks deal with their dependency nightmares themselves, and it will just work for all the people who have adopted Nix.

A similar approach can be adopted if you want to use Guix instead of Nix. In fact, I’m sure the snippet above could be extended to check for the presence of either. If you know Guix, send me an email with the updated snippet and I’ll include it here.

When Not To Use It Link to heading

One scenario where I don’t use this technique is in development repos. Repos tend to end up with a decent amount of helper scripts, and it’s tempting to make use of nix-shell to install dependencies for all of those.

I don’t think you should bother to do that.

Instead dependencies should be managed at the repo level, by using a flake.nix or a shell.nix in the root directory. That keeps things a bit simpler and ensures that all the dependencies are installed in one place, and with the same versions.

Nix: Reasonable Default Configs

Wed, 30 Nov 2022 00:00:00 +0000

Updated October 3, 2024

Updated with help from @poz and others who have reached out with suggestions.

I’ve now been using Nix, the package manager, fulltime on my personal machines since 2021. I run NixOS on my personal desktop/laptop and VMs, so I have some reasonable experience using it.

I really enjoy using Nix, and think it’s a very useful tool, but it definitely needs a lot of tweaking.

Today I want to share some of the config settings in Nix that most users probably want to change. The defaults that Nix uses for these settings don’t make that much sense to me, and most people who actually use Nix should probably consider changing them.

Just a note, Nix had a longstanding bug where it displayed the wrong default values in the manual, so make sure you are looking at the latest unstable Nix manual.

I’ll go into them in detail below, but here are the settings I want to talk about. I’ve grouped them into tiers; Almost always set, Set if understood, and Set for developers.

# Almost always set
connect-timeout = 5
# log-lines = 25 # Updated: This is now the default!
min-free = 128000000
max-free = 1000000000

# Set if understood
experimental-features = nix-command flakes
fallback = true
warn-dirty = false
auto-optimise-store = true

# Set for developers
keep-outputs = true

Almost always set Link to heading

These are settings that I think are no-brainers to change for just about everyone, and they should probably just be the default values.

connect-timeout Link to heading

The timeout (in seconds) for establishing connections in the binary cache substituter. It corresponds to curl’s –connect-timeout option. A value of 0 means no limit.

Default: 0
Reasonable: 5

The default of 0 is equal to a timeout of 300 seconds. This seems pretty unreasonable for most users.

This is especially important if you have multiple caches setup, as any offline caches will just hang for this whole time. Assuming you’ve also set fallback = true, then setting connect-timeout to a reasonable value will let you have binary caches on your local machines that are only occasionally online.

log-lines Link to heading

Update: The default is now 25 in Nix 2.20, so this is no longer necessary.

The number of lines of the tail of the log to show if a build fails.

Default: 10
Reasonable: 25 This is the new default!

These log lines are only shown on a failed build, and I’ve found that usually the last 10 lines aren’t useful for figuring out what actually failed. Setting it to something even a little bit larger is often enough to debug the build.

You can also set this to something very large to output the whole build log.

min-free/max-free Link to heading

When free disk space in /nix/store drops below min-free during a build, Nix performs a garbage-collection until max-free bytes are available or there is no more garbage. A value of 0 (the default) disables this feature.

min-free
- Default: 0
- Reasonable: 128000000 (128 MB)
max-free
- Default: -1
- Reasonable: 1000000000 (1 GB)

Note: These are actually most useful if you setup /nix on it’s own partition, as long as you give it enough space then you never need to manually garbage collect.

Nix has a tendency to use a lot of space, especially if you are developing with it. By default nothing will be deleted unless you manually collect garbage with nix-collect-garbage.

By setting min-free to a reasonable small value, you can ensure that it doesn’t fully fill the partition, which can cause problems if /nix/store is on the same partition as the rest of your system.

Users will probably want to tweak these settings themselves, but changing these settings from the defaults will at least ensure that they don’t run out of disk-space.

Set if understood Link to heading

These settings are things that most users should probably set, but you should definitely understand them first.

experimental-features = flakes Link to heading

Default:
Reasonable: nix-command flakes

This enables the technically experimental feature Flakes.

Most development with Nix recently is using flakes, and as a user you probably want to enable them. If you are a new user especially I’d suggest just using the flakes interface instead of the legacy one.

The current status is that there is an in-progress plan for a plan to stabilize flakes, though there are still lots of very legitimate concerns about them. I’m especially concerned about how they’ve handled the global registry. If possible I’d suggest you disable the global registry as well, but that’s up to you.

Even with the drawbacks though, IMO flakes are just clearly a better interface to use Nix with, and they’ve been in broad use for several years now.

fallback Link to heading

If set to true, Nix will fall back to building from source if a binary substitute fails. This is equivalent to the –fallback flag. The default is false.

Default: false
Reasonable: true

That description is sort of a lie. It’s somewhat common for users to have multiple substituters (caches) setup, either for sharing builds within a company/project or just for caching downloads in your local network. Nix makes it pretty easy to do this on your own machines, especially if they run NixOS, see the wiki.

This setting, if set to false, will cause the build to fail if any of the caches are unavailable. That seems pretty nonsensical, and seems like a common complaint, so I opened a PR to fix it.

Even after that fix goes in, I expect that the way most people expect Nix to work is with this set to true. It is literally setup to have reproducible builds, so failing when caches aren’t available doesn’t make sense in most cases.

Some people may want this set to false, especially on slower devices, but you probably want this set to true.

warn-dirty Link to heading

Whether to warn about dirty Git/Mercurial trees.

Default: true
Reasonable: false

I don’t disagree with the default here, but most people probably don’t need these warnings.

auto-optimise-store Link to heading

If set to true, Nix automatically detects files in the store that have identical contents, and replaces them with hard links to a single copy. This saves disk space. If set to false (the default), you can still run nix-store –optimise to get rid of duplicate files.

Default: false
Reasonable: true

This can save quite a lot of disk space, especially if you upgrade frequently and develop on the machine. I always recommend it, but it does make the layout of /nix/store a little confusing for some people.

Set for developers Link to heading

keep-outputs Link to heading

If true, the garbage collector will keep the outputs of non-garbage derivations. If false (default), outputs will be deleted unless they are GC roots themselves (or reachable from other roots). In general, outputs must be registered as roots separately. However, even if the output of a derivation is registered as a root, the collector will still delete store paths that are used only at build time (e.g., the C compiler, or source tarballs downloaded from the network). To prevent it from doing so, set this option to true.

Default: false
Reasonable: true

This ensures that packages needed for building other packages are kept in the store. If you’re going to be building packages locally, this is very useful to prevent having to redownload things a lot.

Keep in mind that this will cause your nix store to get pretty large.

Replacing Tailscale with a NixOS Module

Fri, 28 Oct 2022 00:00:00 +0000

October 28, 2022

After using Tailscale to manage my Wireguard VPN for the past few months I decided to migrate my network off of it to my own custom configuration. I found that I didn’t need any of the extra features that Tailscale enables, and I enjoyed learning how to manage everything myself.

With NixOS, I was able to recreate the ability to do Endpoint migration to make things a little nicer than a normal barebones setup. My NixOS module lets me configure more than 1 Endpoint per peer and will migrate the connections between them as needed. I only really use this to migrate to/from my Private LAN.

It should go without saying, but Tailscale is (probably) free for you to use. You should probably use that if you don’t want to mess with network settings.

What is Wireguard? Link to heading

Wireguard is a barebones VPN protocol that allows you to create secure connections between machines. It uses a public/private keypair setup similar to ssh, requiring that all the peers you connect to have the public keys of their peers. Each node in the network needs to be configured with a few different things (this is not an exhaustive list, but are the most common options):

An IP address
A Public/Private keypair
A port to use for wireguard connections
A list of Peers that can connect, each containing:
1. The peers Public Key
2. A list of allowed ips that peer is able to send as
3. Optionally, an Endpoint address. An IP address/port combination where the peer is accessible over the public network.

You can also specify an address for DNS and PostUp/PostDown scripts for making any routing changes when the network goes Up/Down.

Wireguard is relatively simple to configure for a static network, requiring only a few pieces of information and not much else. The downside is that it is complicated to make any updates. Changes may have to be mirrored across all devices in the network.

Discovery can also be a problem. The peer must be discoverable using the defined Endpoint for the peer, otherwise the connection may not be available. Typically that means that all of the devices you want to connect to need to have a stable IP:port where they can be reached.

Alternately, you can route from Peer to Peer by using a server that both are connected to. So long as clients can connect to the same Wireguard server, they can route to each other if necessary by going through the server, though the server and the clients need to be configured correctly to make that happen.

The other downside is that only 1 Endpoint can be defined for each peer. The Endpoint is where Wireguard will look for the peer on the public internet to make a connection. For most home users, a peer will often have a public Endpoint (your home IP address + the port you’ve forwarded from your router) and a private Endpoint (the local IP address on the lan), and maybe more. Wireguard has no built-in mechanism for checking multiple Endpoints, or migrating between them.

What is Tailscale? Link to heading

Tailscale manages all the Wireguard problems for you. It handles traversing NATs so that all your peers are reachable, it manages sharing of the public keys among all your devices, and it has a number of nice ease-of-use features built-in to the network (like DNS).

For most people, and especially for large deployments, Tailscale just works. There is even a third-party OSS implementation of their control server, Headscale, if you’d rather self-host and get most of the features.

The vast majority of people should just install Tailscale and be done with it.

For my personal use case though I had a few issues.

It doesn’t play nicely with my “VPN” of choice, Mullvad, even though it probably could.
You must use a third-party identity provider to login, so it makes my VPN dependent on my Google account.
The VPN setup becomes dependent on a Tailscale server to work. I don’t want to be unable to connect to my VPN if Tailscale is down.
I like having bespoke IP addresses which you can’t get with Tailscale.

Manually Configuring Wireguard Link to heading

Because of my concerns with using Tailscale and my desire to make things more complicated than necessary, I migrated my VPN over to a custom setup using a mix of manual management and a NixOS module.

This is only reasonable for me to do because:

I have a small, static network of only a handful of servers and clients.
My home network has a static IP address, and I can configure port forwarding easily.
I don’t have a need to share access to one of these servers with other people, certainly not someone who would also be using Tailscale.
Effectively, I only connect client -> server and never client -> client, which simplifies the setup even more.
Most of my devices run NixOS, so I can turn this from a manual management problem into a software engineering problem.

This has been done and written about before. Most notably, Xe’s post My Automagic NixOS Wireguard Setup. They have since migrated into using Tailscale, since their network became a bit more complex and they wanted some of the niceties that Tailscale offers.

By moving the setup into a NixOS module, I can update the network by making changes in one place, and then pushing the update to all my NixOS machines. I do have to manually manage the config for my NAS, which is not on NixOS, but updating 2 different places turns out to be fairly manageable.

Instead of just configuring Wireguard, this module also sets up a systemd service that will migrate connections to my Private LAN. A few of my Wireguard servers, my NAS and my Desktop, sit on my local network, and I want clients to use either the Public IP:Port associated with them, or use their Private IP:Port when on the local network. This is mostly pointless, since I can still connect to them with the Public IP:Port from my local network, but since I stream a lot of data between those devices it’s better to avoid a hop to/from my ISP that would be required if I routed the packets to my Public IP.

I do still occasionally have some issues with running both Mullvad and this private network together, particularly when trying to SSH between machines outside of the local network. Unlike when I was using Tailscale, restarting the connection has always fixed the problem which I suspect is something going wrong with the iptables routing.

NixOS Module Link to heading

Here’s the code for my NixOS module. It is heavily commented, and to use it you should copy this into your config and customize it for your own network.

{ config, lib, pkgs, ... }:

# Wgnet network
# This contains the network config for my local LAN running over wireguard

# 123.45.67.89 - Fake Home IP address
# 10.41.0.0/16 - LAN addresses with static mapping
# 10.42.0.0/16 - Addresses in the Virtual Wireguard Network

# Adding a new device:
# MANUAL: Create wireguard key(s)
#  Each peer needs to have a public/private keypair created. That can be done with
#  the following commands run as root:
#   > umask 077
#   > wg genkey | tee /var/keys/wgnet.priv.key | wg pubkey > /var/keys/wgnet.pub.key
#   > chmod 0644 /var/keys/wgnet.pub.key
# MANUAL: Setup port forwarding on router for 'server' devices to accept incoming connections

with lib;
let
  cfg = config.modules.services.wgnet;
  homeIP = "123.45.67.89";

  # Define the manual network map based on the host names.
  address = {
    desktop = "10.42.1.1";
    laptop = "10.42.1.2";
    vps = "10.42.1.3";
    nas = "10.42.1.4";
  };

  # Define all the peers in the network
  # Each peer requires
  #  hostname: The hostname, mapped in the hosts file
  #  altHostname: Optional, also mapped in the hosts file)
  #  wgnetAddress: IP to use in the VPN
  #  publicKey: Wireguard public key
  #  publicEndpoint: Optional, publicly addressable location
  #  privateEndpoint: Optional, private address that's not always routable
  devices = [
    {
      hostname = "desktop";
      wgnetAddress = "10.42.1.1";
      publicEndpoint = {
        ip = homeIP;
        port = "54444"; # Forwarded via router
      };
      privateEndpoint = {
        ip = "10.41.1.1";
        port = "53333";
      };
      publicKey = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
    }
    {
      hostname = "laptop";
      wgnetAddress = "10.42.1.2";
      privateEndpoint = {
        ip = "10.41.1.2";
        port = "53333";
      };
      publicKey = "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB";
    }
    { # Virtual Private Server on AWS
      hostname = "vps";
      wgnetAddress = "10.42.1.3";
      publicEndpoint = {
        ip = "98.76.65.43";
        port = "53333";
      };
      publicKey = "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC";
    }
    { # Home NAS in my local network
      hostname = "nas";
      wgnetAddress = "10.42.1.4";
      publicEndpoint = {
        ip = homeIP;
        port = "54445"; # Forwarded via router
      };
      privateEndpoint = {
        ip = "10.41.1.4";
        port = "53333";
      };
      publicKey = "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC";
    }
  ];
in {
  options.modules.services.wgnet = {
    enable = mkEnableOption "wgnet domain";

    address = mkOption {
      type = types.str;
      example = "10.42.1.1";
      default = address.${config.networking.hostName};
      description = "Address of device on the private network.";
    };

    migrate = mkOption {
      type = types.bool;
      default = true;
      description =
        "Run a background service to migrate public -> private endpoints.";
    };
  };

  config = mkIf cfg.enable {
    networking = {
      # Map the hostnames for easy addressing, both as "hostname" and "hostname.wgnet"
      hosts = listToAttrs (map (x: {
        name = x.wgnetAddress;
        value = [ "${x.hostname}" "${x.hostname}.wgnet" ]
          ++ (if (x ? altHostname) then [
            "${x.altHostname}"
            "${x.altHostname}.wgnet"
          ] else
            [ ]);
      }) devices);
      firewall = {
        allowedUDPPorts = [ 53333 ];
        # Force this to false because wg-quick and mullvad don't play nice with each other.
        checkReversePath = lib.mkForce false;
        # Trust all traffic on this interface
        trustedInterfaces = [ "wgnet" ];
      };
      wg-quick.interfaces.wgnet = {
        privateKeyFile = "/var/keys/wgnet.priv.key";
        address = [ "${cfg.address}/16" ];
        listenPort = 53333;

        # There is no problem with having a peer device listed for itself, it is ignored.
        # Endpoints are a hint as to were to find the device, but connections can be accepted from anywhere.

        # Maps the devices list to configured Wireguard peers.
        # It adds an endpoint if that device has a public endpoint, which
        # should be the case for all servers.
        peers = map (x: {
          inherit (x) publicKey;
          allowedIPs = [ "${x.wgnetAddress}/32" ];
          endpoint = if (x ? publicEndpoint) then
            "${x.publicEndpoint.ip}:${x.publicEndpoint.port}"
          else
            null;
        }) devices;
      };
    };

    # This script runs manually to move wireguard connections to the LAN if applicable.
    # This is necessary because we want the roaming devices to know how to connect back using the homeIP, but also to use to prefer the private IPs.
    # Wireguard doesn't support listing multiple endpoints for devices, which would be a better fix.
    systemd.services.wgnet-to-lan = mkIf cfg.migrate {
      description = "Attempt to migrate wireguard connections to LAN.";
      wantedBy = [ "wg-quick-wgnet.service" ];
      # Run every 5 minutes
      startAt = [ "*:0/5" ];

      # Check all peers with both a private and public endpoint and attempt to migrate them.
      # Script resets the endpoint iff
      #   1. We can see the device locally and through the wireguard tunnel
      #   2. The wireguard tunnel doesn't already see it locally
      script = let
        # Setup shorthand links for readability
        wg = "${pkgs.wireguard-tools}/bin/wg";
        grep = "${pkgs.gnugrep}/bin/grep";
        ping = "${pkgs.unixtools.ping}/bin/ping";
      in concatStringsSep "\n" (map (x:
        if (x.hostname != "${config.networking.hostName}" && x ? publicEndpoint
          && x ? privateEndpoint) then ''
            if ! ${wg} show wgnet endpoints | ${grep} -q ${x.privateEndpoint.ip}; then
              if ${ping} -c1 ${x.privateEndpoint.ip} && ${ping} -c1 ${x.wgnetAddress}; then
                echo "Attempting to reset peer ${x.hostname} endpoint to ${x.privateEndpoint.ip}"
                ${wg} set wgnet peer ${x.publicKey} endpoint ${x.privateEndpoint.ip}:${x.privateEndpoint.port}
                if ! ${ping} -c1 ${x.wgnetAddress}; then
                  echo "Failed to reset peer ${x.hostname} to ${x.privateEndpoint.ip}. Reverting to ${x.publicEndpoint.ip}."
                  ${wg} set wgnet peer ${x.publicKey} endpoint ${x.publicEndpoint.ip}:${x.publicEndpoint.port}
                fi
              fi
            fi
          '' else
          "") devices);
    };
  };
}

Rust Coreutils: Fixing Low-Hanging Performance Fruit

Tue, 13 Sep 2022 00:00:00 +0000

September 13, 2022

I have been toying with learning Rust for the last few years, but since I wasn’t able to use it at work it never really stuck with me. Throughout my career I mainly worked on low-latency C/C++ systems, and on performance engineering work directly (benchmarking, optimization work, etc) and Rust is trying to play in the same ballpark. Since retiring at the start of this year I’ve had a little more free time, so I’ve been spending more time writing Rust code for my personal projects and trying to contribute to some Rust OSS projects to get a feel for the language.

A few months ago I took a look at the uutils coreutils project, which is a rewrite of the core GNU utils in Rust, to try to get some experience writing newbie code in the language. I saw the maintainers themselves mention that a lot of the code quality isn’t great since a lot of contributions are from people who are very new to Rust, so I figured there would be some easy fixes available for me to take on.

I ended up making 2 quick contributions that sped up the uutils dd tool by 2-3x.

	bs=4k count=1000000	bs=1M count=20000	bs=1G count=10
GNU dd (baseline)	1.15s	1.07s	1.13s
Coreutils dd	2.14s	1.98s	5.98s
Coreutils dd (with #3600)	1.99s	1.60s	1.95s
Coreutils dd (with #3610)	1.29s	1.79s	5.96s
Coreutils dd (with both fixes)	1.15s	1.42s	1.90s

These results are for copying from /dev/zero to /dev/null to limit I/O impact and measure dd overhead as closely as possible. The commands used are something like: time dd status=progress bs=1G count=10 < /dev/zero > /dev/null

Understanding “dd” Link to heading

I want to explain the two changes I made, but first we need a little background on the dd tool. dd is used to copy (and sometimes convert, which we’ll be ignoring) data from one file to another. It can be setup to copy a specific number of bytes and can be configured to copy in blocks of a specified size.

If you’ve ever installed an .iso file to a USB drive on linux, you’ve probably been directed to use dd with a command that looks something like this:

> dd if=ubuntu-22.04.iso of=/dev/sdb bs=4096

That command sets the input file if, the output file of, and the blocksize bs (in bytes).

dd works by taking the following steps on its main loop:

Read blocksize bytes from the input file into a buffer.
Apply some conversions, if applicable.
Write the buffer to the output file.
Repeat from step 1 until finished (until it has written count blocks, it’s hit the end of the file, or it errors out).

Before I made any changes, here is the main loop for the dd utility in the uutils project: source link

        // Start a thread that reports transfer progress.
        //
        // When `status=progress` is given on the command-line, the
        // `dd` program reports its progress every second or so. We
        // perform this reporting in a new thread so as not to take
        // any CPU time away from the actual reading and writing of
        // data. We send a `ProgUpdate` from the transmitter `prog_tx`
        // to the receives `rx`, and the receiver prints the transfer
        // information.
        let (prog_tx, rx) = mpsc::channel();
        thread::spawn(gen_prog_updater(rx, i.print_level));

        // The main read/write loop.
        //
        // Each iteration reads blocks from the input and writes
        // blocks to this output. Read/write statistics are updated on
        // each iteration and cumulative statistics are reported to
        // the progress reporting thread.
        while below_count_limit(&i.count, &rstat, &wstat) {
            // Read a block from the input then write the block to the output.
            //
            // As an optimization, make an educated guess about the
            // best buffer size for reading based on the number of
            // blocks already read and the number of blocks remaining.
            let loop_bsize = calc_loop_bsize(&i.count, &rstat, &wstat, i.ibs, bsize);
            let (rstat_update, buf) = read_helper(&mut i, loop_bsize)?;
            if rstat_update.is_empty() {
                break;
            }
            let wstat_update = self.write_blocks(&buf)?;

            // Update the read/write stats and inform the progress thread.
            //
            // If the receiver is disconnected, `send()` returns an
            // error. Since it is just reporting progress and is not
            // crucial to the operation of `dd`, let's just ignore the
            // error.
            rstat += rstat_update;
            wstat += wstat_update;
            let prog_update = ProgUpdate::new(rstat, wstat, start.elapsed());
            prog_tx.send(prog_update).unwrap_or(());
        }

Performance Problem #1: Buffer Reuse Link to heading

The first problem becomes most obvious when dd is used with a large blocksize. I initially started looking at dd because of Issue #3094, which hinted at the problem.

The problem is that the main loop above doesn’t reuse the same buffer for each copy. What the block above does is allocate a new buffer of blocksize bytes, then read from the input file into that buffer, write the output, then discard the buffer.

What you want to do instead is to reuse the buffer to avoid reallocating memory. This is one of those problems that people who work in a higher level GC’d language (like Javascript/Python) often miss while learning systems programming, so it’s not too surprising to find something like this in a newbie Rust project. Rust tends to have a mix of both experienced systems programmers looking for an upgraded C++ (like me) and from web developers looking to write native code for the first time.

Interestingly, this is actually a problem that Rust is pretty uniquely suited to solve safely. Safely reusing a buffer of memory is one of the problems that Rust’s design is intended to help with. The actual code change was relatively small, and Rust helped ensure that it was safe.

This change alone sped up large blocksize copies by up to 3x.

Performance Problem #2: Thread Communication Link to heading

The second problem here is a little less obvious, but shows up mainly when working with small blocksizes.

Whoever wrote this code originally intended to optimize it by moving all of the output to a separate thread, as you can see from the comments. This resulted in sending a message to the output thread after every block was written in order to update the status bar.

dd only outputs the progress once every second to avoid spending too much time printing. The check to see if 1 second had passed was being done in the second thread, so the second thread would be woken up after every block was written but only have output to print once per second.

This is a perfect example of premature optimization, and, like the previous problem, also seems to come from someone unfamiliar with systems programming. Thread-to-thread communication is actually fairly expensive relative to other low-level operations, but you probably won’t think of it that way if you’re writing a higher-level language.

In common usage, blocksizes are in the Kilobyte range, so often this loop will be iterated over thousands of times per second. I have real doubts that sending a message between threads like this is significantly faster than printing a line of text, but sending thousands of messages per second is definitely slower than printing once per second.

My fix was ultimately a general fixing of problems related to output, which included a fix to only wake up the printing thread once per second. There were several other related bugs dealing with with the output that I also fixed, you can look at the PR for more info.

Ultimately I didn’t remove the second printing thread entirely because one signal per second wasn’t ever going to have a significant performance impact, and the code is organized around having that extra thread. It’s still there, but from a performance standpoint there’s certainly no reason for it.

For the smallest commonly used blocksize of 4K, this change alone sped up dd by almost 2x.

The Final Form Link to heading

After my changes the core loop looks like so:

        // Start a thread that reports transfer progress.
        //
        // The `dd` program reports its progress after every block is written,
        // at most every 1 second, and only if `status=progress` is given on
        // the command-line or a SIGUSR1 signal is received. We
        // perform this reporting in a new thread so as not to take
        // any CPU time away from the actual reading and writing of
        // data. We send a `ProgUpdate` from the transmitter `prog_tx`
        // to the receives `rx`, and the receiver prints the transfer
        // information.
        let (prog_tx, rx) = mpsc::channel();
        let output_thread = thread::spawn(gen_prog_updater(rx, i.print_level));
        let mut progress_as_secs = 0;

        // Create a common buffer with a capacity of the block size.
        // This is the max size needed.
        let mut buf = vec![BUF_INIT_BYTE; bsize];

        // The main read/write loop.
        //
        // Each iteration reads blocks from the input and writes
        // blocks to this output. Read/write statistics are updated on
        // each iteration and cumulative statistics are reported to
        // the progress reporting thread.
        while below_count_limit(&i.count, &rstat, &wstat) {
            // Read a block from the input then write the block to the output.
            //
            // As an optimization, make an educated guess about the
            // best buffer size for reading based on the number of
            // blocks already read and the number of blocks remaining.
            let loop_bsize = calc_loop_bsize(&i.count, &rstat, &wstat, i.ibs, bsize);
            let rstat_update = read_helper(&mut i, &mut buf, loop_bsize)?;
            if rstat_update.is_empty() {
                break;
            }
            let wstat_update = self.write_blocks(&buf)?;

            // Update the read/write stats and inform the progress thread once per second.
            //
            // If the receiver is disconnected, `send()` returns an
            // error. Since it is just reporting progress and is not
            // crucial to the operation of `dd`, let's just ignore the
            // error.
            rstat += rstat_update;
            wstat += wstat_update;
            let prog_update = ProgUpdate::new(rstat, wstat, start.elapsed(), false);
            if prog_update.duration.as_secs() >= progress_as_secs {
                progress_as_secs = prog_update.duration.as_secs() + 1;
                prog_tx.send(prog_update).unwrap_or(());
            }
        }

Conclusions Link to heading

I enjoyed these little code fixes, they gave me a chance to practice some of my Rust skills and maybe help out the community if this project ever becomes more popular. I’ve occasionally done similar fixes, or looked into other performance problems in different projects, so I may write up more about them in the future.

For anyone wanting to do something similar checking out the PRs I’ve linked here will point you to several more areas for optimization or fixes in just this one tool.

Stimulus Bundling for Good and Evil

Thu, 21 Jul 2016 00:00:00 +0000

If you enjoy something, you’ll tend to do it more often.

Obviously.

However, there tend to be a lot of things that you know are good for you, but that aren’t exactly enjoyable. Today we’re going to try to fix that through a technique I call Stimulus Bundling; the goal of which is to make those healthy but boring things more enjoyable.

The example I’ll be using today is exercise, but it can also apply to any number of other things: cooking rather than eating out, working on your side project or hobby, reading instead of watching TV, etc.

The basic idea is simple: bundle together something you genuinely enjoy with something you want to enjoy.

We can also use this technique for the opposite case as well, for trying to eliminate things you know are bad for you but that are enjoyable. I’ll discuss that at the end.

People vs Dogs Link to heading

All we’re really doing here is using Classical Conditioning, AKA Pavlovian Conditioning, to modify your response to stimuli. You have probably heard about it from the example of Pavlov’s dogs.

Ivan Pavlov ran an experiment in which he conditioned dogs to salivate in response to a totally unrelated stimulus (a buzzer, as it’s usually related, though I couldn’t find a direct confirmation). He did this by setting the buzzer off every time the dogs were fed so that later the dogs began to anticipate food whenever they heard the buzzer. The dogs learned to associate the buzzer with food directly.

Humans are smarter than dogs [citation needed] but the same general principle applies to us as well. Bundle together the things that are good but boring with the things you find enjoyable. Eventually, you will be trained to enjoy them both.

Positive Training In Practice Link to heading

At this point, you’re probably thinking I’m an idiot, because obviously everybody knows that. Lots of people set up rewards for themselves whenever they stick to their goals. Whenever they workout they reward themselves with a smoothie, or ice cream, or a day off of working out.

Well, that’s not the same thing. That methodology (of rewards and punishments) is Operant Conditioning and while it can be used to influence behavior it doesn’t necessarily encourage you to enjoy the act.

The goal should not be to mollify yourself after you’ve done something you don’t like, it should be to train yourself to start enjoying it.

Classical Conditioning can help us do that. And once we start enjoying it we’ll start doing it more without having to exert any unnecessary Willpower.

Classical Conditioning works best when the two stimuli are done either concurrently or very close together (i.e. on the order of seconds), so rewarding yourself after the fact isn’t going to help. The goal then is to find something you can do concurrently with the difficult activity.

What you pair with your difficult activity is up to you, but you should pick something that is enjoyable and is not directly bad for you.

I’ve always found that the best things to pair with exercise, or other relatively monotonous work, are things you can listen to or watch while your exercise. For example, you could listen to or watch:

An audiobook
Your favorite TV show
An informational podcast
Or music

After a few sessions, you’ll start to associate working out with the enjoyment you get from those entertainments. And every time you see references to your entertainment you’ll start to crave a workout.

This effect sticks around for quite a long time. For a month or two back in college, I listened to one particular album on repeat while working out on an exercise bike a few times a week. It was probably 10-20 workouts total.

It’s been half a decade but I still feel like working out whenever I hear those songs.

The real key to building this association is the more difficult part: whatever you pick, do it as little as possible outside of your paired activity.

Keep them exclusive as much as possible. If you’re watching your favorite TV show(s) while you’re on the treadmill, don’t watch them while you’re not. You’ll get the added incentive to go workout just so you get to see what happens next, and you’ll cement the association faster.

Negative Training In Practice Link to heading

As much as you can use this technique for making healthy activities enjoyable, you can also use this for making unhealthy enjoyable things even more addictive.

Using the same principle above, what do you think happens when you spend a few evenings a week watching your favorite TV show and eating dessert?

Those two things become very enjoyable for you. A few days a week turns into every single day, and it becomes difficult to only watch TV and not eat dessert with it.

This is what fast food companies catch you with using a combination of sugar, salt, and fat. Bars take it a step further by adding alcohol into the mix too.

This is what movie theaters do when they teach you that movies must be enjoyed with popcorn and soda. If you have them both together often enough you’ll always need popcorn at the movies or it will feel like something’s missing.

And it’s also what you do to yourself whenever you take your unhealthy things in groups.

Just be aware of what you’re doing to yourself, of how you are conditioning your own expectations.

Rules to Live By Link to heading

What you need to learn from Stimulus Bundling can be broken down into 3 simple rules.

Pair a healthy, boring stimuli with something else that is enjoyable and non-detrimental.
Never do one without the other.
Don’t pair two unhealthy, enjoyable stimuli together.

You Need a Password Manager

Wed, 13 Jul 2016 00:00:00 +0000

Today I’m going to talk about something that may seem a little off-topic; you need to have better passwords for your online accounts.

This is probably not news to you. Every time a big website gets hacked there is a flood of news stories about the dangers of weak passwords, but it always dies down quickly. You might feel guilty about using ‘123456’ as your password for a couple days, but you’ll eventually forget about it once the media stops reminding you.

Here’s the bottom line; if you are not using a different, strong password for every online account, you are putting yourself at unnecessary risk.

Luckily there’s a simple way to do that. All while actually making it easier for you to remember your passwords. Just use a password manager.

But before I get to talking about that, I’m going to try and explain why you actually need one. Where the risks actually come from.

What’s the deal with Passwords Link to heading

The risks that I’m talking about are not what you first think of when you hear the phrase ‘steal your password’. I’m not talking about somebody who stands behind you at the coffee shop and watches you type it in. Nor the risk of somebody compromising your computer with a virus. Nor the risk of somebody in a coffee shop snooping on the wifi and grabbing your passwords from any unsecured traffic.

Password managers will actually help with those, but most people already understand how to prevent them. Don’t type an easy password in with a stranger over your shoulder, install some antivirus on your computer, and make sure the websites you log into use HTTPS. (Ok, maybe the last one isn’t that obvious.)

But what we’re concerned about today is the big breaches. It’s not about some individual trying to steal your login, it’s about some individual trying to steal millions of logins.

Let me explain.

When you create an account on a website, let’s say Example.com, they need to store your login information.

Idea #1 Link to heading

At Example.com they’re pretty naive. So they take your username and your password and store them together in a database. When you log in they compare your username and password against the database and if they match, they let you in. If you ever forget your password, they can just email it to you.

This works perfectly until somebody hacks in and steals the database, and they can read all the passwords.

Idea #2 Link to heading

In response, Example.com upgrades their security. Now instead of storing them in plain text they encrypt all of the passwords. Whenever you log in they just decrypt your password stored in the database and use that to check if you got it right. As a bonus, if you ever forget your password they are still able to just email it to you.

This works perfectly until somebody steals their database and their encryption key, which they had to store on the same computer, and decrypts all the passwords.

(No website today should ever do either of those. If any website is ever able to email you your password, run away and don’t look back. Then never use that password again.)

Idea #3 Link to heading

Now they get creative. There is a type of computer algorithm that is one-way ’encryption’, called hashing algorithms. These algorithms take an input, such as a password, and produce an output ‘hash’ that is unique to that input. So every time they run your password through that algorithm it returns the same semi-random output.

What makes hashing algorithms interesting is that there’s no way to get from the output hash to the input password.

Now Example.com will save in their database your username (in plain text) and your hashed password. When you log in, they take your password, run it through their hashing algorithm, and compare the result against the saved hash. If you forget your password, they won’t be able to send it to you because even they don’t know what it is.

Example.com is now up to par with many websites out there today. Often when there is a ‘password breach’ it’s somebody stealing a database containing plain text usernames and the password hashes, just like I’ve described. The passwords leaked in the last couple months from LinkedIn were secured like this.

This is what we’re trying to secure against by using a password manager.

Why It’s Still Broken Link to heading

The problem with this scheme is not immediately obvious.

If you had an account with Example.com and your password was ‘123456’, and they used the hashing algorithm MD5, your password hash would be: E10ADC3949BA59ABBE56E057F20F883E

In fact, everybody who used ‘123456’ would have the same password hash. All an attacker has to do is check to see whose password hash is E10ADC3949BA59ABBE56E057F20F883E and they’ll know that your password is ‘123456’.

Amusingly, if you store password hints alongside the password hashes into the database, a leaked password database becomes The Greatest Crossword Puzzle in the History of the World. Line up the password hashes and you get multiple hints to explain a single password.

To find the passwords, an attacker will take every password they can think of, generate the hash value, and check to see if the hash value is in the database. The more passwords they check the longer it takes them, so they use lists of the most common passwords, dictionary words, basic changes to dictionary words, and ultimately random guessing.

Every password they check takes time, as they have to compute the hash then check it against the database. A good hash algorithm is actually somewhat slow, so it takes longer to check each password, but not too slow that it takes a long time for you to log in.

What you need to do is make sure your password is not one of the passwords that they can check in a reasonable amount of time. Because their ability to ‘guess’ what the passwords may be is very very good, you should assume that anything you can remember easily is not secure. Thus, you need to use a complex password that you can’t easily remember.

If you reuse passwords for multiple websites, you are trusting all of them to keep that password secure for you. If any one of them doesn’t store their passwords correctly, and you reuse your username, then none of those accounts are secure. Once a hacker finds your password at one site, they will try the same username/password combination at other sites. So it’s good to have different passwords for everything.

If you’re still hoping that the websites you use probably have good security practices, remember that LinkedIn, a multi-billion dollar company, didn’t do this correctly.

So the best thing you can do to keep your accounts secure is to have a unique, difficult to remember password for every account. The only easy way to do that is with a password manager.

There is actually a better way for a website to store passwords, called password salting. Basically, they generate a random ‘salt’ they store in the database (in plain text) along with your username and password. When you log in, they take your password, add the salt to it, then they hash that whole thing to compare to your stored password hash. Since the ‘salt’ is unique to your account, any attacker would have to try to crack your password individually, instead of being able to crack all of the passwords at the same time.

So a Password Manager Link to heading

Using a password manager helps you solve the two basic problems most people have with their passwords: uniqueness and complexity.

Since you don’t have to remember your passwords you can have a different password for every single account. That way if one of them is breached only one of your accounts will be compromised. If you have hundreds of different accounts like I do, there is no way you can keep track of them all without a password manager.

Since you don’t have to remember your passwords, they can all be very complex. “ap49nQXj*ro@” is a strong password, but would take most people quite a bit of effort to memorize. My password manager will generate it and save it for me in seconds.

With a password manager, you will only have to memorize one strong password, your ‘master password’, and all the rest will be stored for you.

There are a number of options to choose from, but for the most part all of them will have the same basic set of features.

A very secure ‘vault’ for storing all your passwords.
A ‘password generator’ to create new passwords. Humans are notoriously bad at generating random passwords.
Simple ways to access your passwords, like a browser extension.

Personally, I use LastPass, but I’ve also heard very good things about the usability of 1Password. Between the two of them is really a matter of preferences.

The only downside to those two options is that you have to trust those companies to some extent. If you are extra paranoid then the best option is KeePass, but it might be more effort than it’s worth.

Look into the options for yourself, pick the one you’re comfortable with, and then actually use it.

I Logged All My Eating for a Month

Tue, 21 Jun 2016 00:00:00 +0000

Recently I’ve been trying to lose a bit of weight.

Not a lot, just 10-15 pounds. I’m relatively fit but I’ve packed on a little bit of unwanted fat over the years.

For a few months I did the easy thing. I said to myself ‘Hey, we’re gonna lose weight now,’ then proceeded to do mostly nothing.

I was arrogant enough to believe that because I wanted to lose weight, and because I knew how to eat healthy, that I would actually drop those pounds without effort. That I could just go about my day and make smart food choices that would result in me eating at a low enough deficit to drop weight.

In short, I was an idiot. I actually mentioned how much of a bad idea that is back on this blog, while I was doing it myself. Obviously it didn’t work.

So a month ago I decided to try an experiment: I would actually listen to what I already knew was the best advice for losing weight. I would actually track all of my food intake.

There have been a rather large number of studies showing that tracking your eating in a food diary helps people lose weight. You don’t even have to track calories if you don’t want to, the mere act of keeping track of what you’re eating forces you to make healthier food choices. The assumption is that when you have to keep track of your food you will make better choices about what you’re eating. A 2008 study, for example, [showed that keeping a food diary will double weight loss.]

Even while I was starting I still assumed that I wouldn’t have to change my eating habits much. I assumed that I’d start tracking my food and just confirm my already perfect eating habits.

I very quickly learned that that was not the case at all.

The Plan Link to heading

Every day I did two things: tracked everything I ate, and logged my weight and body fat percentage every day.

I need to clarify two things in there:

First, the reason I logged my weight every day is because I assumed my weight would not change very much, if at all, so having a marker every day would help me see if there was a trend. You really should not do this if you aren’t prepared to see your weight fluctuate by up to several pounds a day. (It’s due to hydration and food intake, not actually gaining or losing weight.) You’ll freak out if it’s high for a few days and be tempted to celebrate with more food if it looks like you ’lost’ several pounds since the day before.

Second, I measured body fat percent with one of these electronic scales. The method that these use to measure body-fat is not very accurate but it’s possible they could help show a trend. This will hopefully help illustrate that I’m losing a greater percentage of fat than I am of lean body mass.

The Results Link to heading

On day one I weighed 186.6 pounds at a body fat percentage of 17.4%.

On day 30 I weighed 180.2 pounds at a body fat percentage of 16.4%.

Today (day ~35) I weigh 179 pounds at a body fat percentage of 16.0%.

Even taking into account regular weight fluctuations, at a minimum I lost 3-4 pounds. Keep in mind this is after several months of ’trying’ without losing anything, and somewhere between 3 and 7 pounds in a month is a decent amount of weight to lose for someone of my size.

More valuable to me than just the weight coming off was what I learned from doing this.

Here’s What I Learned Link to heading

I was grossly over- or under-estimating the calories in my food Link to heading

Some meals or snacks that I thought weren’t too bad, like cheese and salami, turned out to be quite a bit higher in calories than I thought. I mean, I knew there was a decent amount of calories in cheese but I didn’t realize there were 120 calories per ounce.

In the opposite direction, the side of veggies that I usually have with dinner had even fewer calories than I thought. Riced cauliflower, which I’ve grown partial to as a ‘rice’ replacement, has only ~120 calories per pound. Coincidentally, that’s the same number of calories that are in the tablespoon of oil or butter that I cook it in.

You may have seen these comparisons online before, pictures of what the same number of calories look like in different foods, but it doesn’t really sink in until you pay attention to them for quite a bit longer than the time it takes to read about it.

It was only difficult at first Link to heading

At the beginning of the month it was somewhat difficult. At the end of every day I was still feeling hungry; I really just wanted to sit down and eat a huge dessert.

But no matter how big the dessert was I’d still be hungry. And interestingly, even going to bed hungry I wouldn’t wake up hungry at all. I usually wouldn’t feel hungry again until noon.

Clearly my body just wanted me to eat more for no real reason. I got through it either by snacking on veggies or by having a small dessert and sucking it up.

After 2 weeks or so, that feeling mostly went away. Either I got used to it or I adjusted to the calories, either way it wasn’t nearly as difficult.

Use a tool Link to heading

This is a lot easier if you use something like MyFitnessPal. Their food diary is built for this, and you can fairly easily just look up the nutrition info for something you’re eating inside of the tool.

Setting up an account on MyFitnessPal will help you figure out what your caloric needs for each day are. Just go through their short questionnaire, tell it if you’re trying to lose, gain, or maintain your weight, and it’ll estimate how many calories a day you should be eating.

This is monumentally easier and more useful than writing it down in a notebook. I bet it’d take 10x longer if you wanted to track how many calories you were eating by hand.

If you’re going to log it, Don’t Wait Link to heading

The longer you wait after you eat the less likely it is you’ll actually write it down. Truthfully I sometimes took to even logging my food before I ate it. That way I knew what I was getting into.

The several days in the past month where I didn’t log what I ate were caused by this. I got distracted and didn’t take the time to log it while I was eating, so I slipped up.

It happens, just keep going starting with your next meal.

If you’re not exact, overestimate Link to heading

There will come a time when you don’t know exactly how much stuff you just ate. Was that one cup of rice or one and a half? How much butter did I use for my eggs?

The best way to log that is to be perfect. Weigh all your food using your kitchen scale and log it down to the gram.

The second best way is to do it occasionally, and use that to estimate all the other times. Use the scale to calibrate your food estimating superpower.

But since you aren’t going to be perfect no matter which way you go, overestimate. Round up your estimates a little bit to give yourself some extra leeway.

[Note that if you are trying to gain weight, obviously you should do the opposite. Underestimate a little bit in your estimates.]

Don’t Panic Link to heading

There is not a lot of harm in missing your eating goals for the day, so long as you aren’t doing it every day.

Some days I went over my calorie goal by a couple hundred, but most days I was comfortably under.

What I’m Doing Now Link to heading

At the end of my 30 days I decided that I’d do a different trial. For the next 30 days I’m going back to not keeping a food diary.

I’m curious to see if I’ll continue losing weight without actually tracking all of my food. My theory is that I will lose some, but maybe not as much as I did during the trial. I am hoping that the things I learned about my eating and the habits I started to form over the past month will help me stay on track.

What made me hopeful that that is actually true and not wishful thinking was a recent trip to Vegas.

Last weekend, just before my food diary trial ended, my girlfriend and I went to Vegas. Since we understand math enough to not bother gambling, we went to enjoy the shows and the food, so to better enjoy the short vacation I decided not to log any of my food for those days. I can enjoy a steak more if I ignore the fact that it’s 1000 calories.

That decision was a little risky. I’m prone to binge eating so it could have gone horribly with the fancy Vegas buffets, but it didn’t. Compared to my past habits, I felt much more satisfied with less food. I ate as much as I wanted, but it wasn’t more food than I needed.

The day after we came back was the end of my 30 days, and I hit the lowest weight of the trial.

So now I’m going to see if I can keep up the weight loss without tracking everything. The only thing I’ll track is my weight, so I can have some marker for progress.

If I lose about the same amount of weight again, putting me down to somewhere in the 174-176 range, I’ll call it a success, otherwise I’ll go back to tracking everything.

I’ll touch back here next month to update how it went.

The Weekly Review

Tue, 24 May 2016 00:00:00 +0000

Feeling like you’re working hard but not getting anything done? As if you don’t know what you actually accomplished in the past month or 3?

The simple truth is: you’re disorganized.

I’m not talking about how clean your home is, you are disorganized in how you manage your time. Your productivity system is in shambles.

Sure, maybe you have all 327 tasks you need to do saved to your favorite task manager that you can access from your smartwatch at all times of the day or night, but that doesn’t mean you’re getting any of them done. And it definitely doesn’t mean you’re getting the right tasks done at the right time.

If you’re spinning your wheels, feeling disorganized or not ‘on top’ of things, you’re almost certainly neglecting an essential part of any productivity system: The Weekly Review.

Basics of a Productivity System Link to heading

Your personal productivity system probably doesn’t align perfectly with anything spouted by the ’experts’. Though to be honest, there are so many different supposed ‘correct’ systems that you’d never be able to figure that out anyways.

Or maybe you don’t have any system at all, in which case you should probably fix that.

Personally, I tend to work with a mix of GTD (Getting Things Done) and Deep Work. Most of what I’m talking about today is taken from the Weekly Review ideas in GTD.

Regardless of what system you are using, any good, complete system is going to have a few things in common.

Track tasks somewhere outside your own head.
Schedule work according to its importance/deadline.
Do the work.
Review the results and course correct.

And that’s really it. You can add all sorts of other things on top of that; Inbox Zero, Pomodoro Sprints, etc. You can organize everything using a notebook or in the cloud. It doesn’t matter.

What matters is that it works for you.

The problem is that a lot of people forget about that last bit, the Review. Some days it can feel pointless, and not worth your time. After all, you know what you’ve already completed.

But it is important. It’s an opportunity for you to review what you’ve been doing, ensure you’re on track, and look to the future to see where you want to go.

Think of it as a weekly check in with yourself. It’s a time to touch base with all of the things in your life, both personal and professional, that you care about. It’s a time to think about not just doing work, but to take a step back and review the how and the why of the work you’re doing.

Most importantly, it’s a time to view all of your life together in one place and plan the direction you want to go. A high-level planning session if you will.

So let’s get started.

Schedule Your Review Link to heading

Start by scheduling the review in your calendar. The first time may take you an hour or two if you’re being thorough, but after doing one or two it will probably take less time (especially if you’re on top of things).

You can do one as often as you’d like, but once a week tends to work best. Schedule it either for the end of your workweek or the beginning of your workweek.

Personally, I block off time at the end of my workweek to go through it. Doing it just before the weekend helps to clear my head of work and unload that from my mind. Knowing that I’m up to date on everything helps keep me from thinking about work too much so I can enjoy the weekend.

When I get back to work on Monday mornings I like to plan out my work for the week as much as possible. Reading through the Weekly Review from the week before re-loads all of that information into my mind, and helps me make smart decisions on where I should be directing my efforts for the week.

You could, of course, do both your planning and review at the same time. I prefer to split them up because it gives me some solid bookends for my weeks worth of work. I start the week by scheduling work by importance into time blocks, and I end the week by taking a higher level look at my progress and performance, which then feeds into how I prioritize and schedule work for the following week.

Do the Weekly Review Link to heading

When it comes time to do the review, don’t try to remember everything you need to do. Use a checklist.

The GTD community has created lots of complicated templates to provide direction on doing a review, but personally I find simpler is better. Here is the very basic Weekly Review Checklist that I use [PDF Warning]. I customized mine a little bit, but overall it is still very similar. I’d suggest you do the same; start with this simple checklist and, once you start to see what works for you, make changes to it to suit your own needs.

Let me walk through and explain the different steps. If you’re not familiar with GTD then some of their explanations probably won’t make sense.

The Weekly Review has three different parts: Get Clear, Get Current, and Get Creative.

Get Clear Link to heading

We start by getting all your various inboxes cleared out. If you’ve stayed on top of this throughout the week it won’t take long.

Collect Loose Papers and Materials
- Gather together everything you need to process. Receipts, notes, etc. If you don’t work with paper do this digitally.
Get “IN” to Zero
- Inbox Zero. Everything you need to ‘process’ you should. Make sure everything in your Inboxes (physical and digital) are sorted out and processed. You shouldn’t have any unknown things you need to do after this is done.
Empty Your Head
- Put down into your task list/calendar/notebook anything you haven’t yet written down. Don’t rely on your memory to keep track of things you need to do.
- Many people find that a ‘Trigger List’ of potential tasks is useful to remind them of things to do. Something like this.

Get Current Link to heading

Next, we review everything to get up to date. Check in with everything you’ve got going on and everything you need to do, don’t leave anything out.

Review Action Lists
- Read through your task list. Mark off things you’ve completed and ensure it’s organized how you like.
- If I find a couple small (<2 minute) tasks that I’ve forgotten about I tend to just do them immediately.
Review Previous Calendar Data
- Check in with what you did this past week for any remaining tasks or follow-up.
- What I also like to do is review how successfully I managed my time over the past week. While going over the past calendar I ask myself:
  - What was my most useful time spent?
  - What was my least useful time spent?
Review Upcoming Calendar
- Review what you’re doing next week (or even farther out). Schedule anything you need to do to prepare, or resolve any conflicts you find.
Review Waiting For List
- Check your lists of things that you are waiting for. E.g. waiting for an email response? Ping them or schedule a follow-up.
Review Project (and Larger Outcome) Lists
- Evaluate status of projects, goals, and outcomes, one by one, ensuring at least one current action item on each. Browse through project plans, support material, and any other work-in-progress material to trigger new actions, completions, waiting for’s, etc.
Review Any Relevant Checklists
- Use as a trigger for any new actions.

Get Creative Link to heading

Lastly, we look towards the future. This is a time to plan for things you want to do (personally or professionally) and try to fit them into your calendar.

Review Someday Maybe List
- For GTD, this is a combined Bucket List / Future Projects list. While going over these look for next steps you can fit into your schedule.
  - The Future Self is my personal ‘Someday Maybe’ list, and I review it at this point.
- You may find it helpful to also have a work related ‘Someday Maybe’ list. Keep a list of professional development things you want to do, future work-related projects, etc.
Be Creative and Courageous
- Any new, wonderful, hare-brained, creative, thought-provoking, risk-taking ideas to add into your system??? Add it to your Future Self list and start planning for it.

That’s It Link to heading

That’s all there is to it. At the end of your Review you should be up to date on everything you’re doing in your personal and professional life. You shouldn’t have any outstanding work to do that isn’t scheduled (or at least saved and written down). You should be aware of all your future plans, and you should be comfortable with how your next few weeks are going to go.

Most importantly, you should know whether or not you’re on track to what you want to be doing. And if you’re not, this is the time for you to identify that and schedule time to get back on track.

Remember, this is something you should enjoy. It’s a time for you to take stock and sort through your life. To figure out what you’re doing and where you’re going.

So indulge yourself a little. Go to your favorite coffee shop, or work on it over a glass of wine. Celebrate a little, it’s the end of a long (and hopefully productive) week.

Just don’t forget to work on it, it will probably turn out to be the most valuable hour of work you do all week.

Why You Will Fail to Act in an Emergency

Tue, 17 May 2016 00:00:00 +0000

On a cold winter night in 1964, Catherine ‘Kitty’ Genovese was attacked outside her apartment in Queens, New York. Coming back from work at 3 a.m., she was stabbed in the back but managed to scare away her attacker. Several minutes later her attacker returned, raped her, and ultimately killed her.

The New York Times reported that 37 or 38 people witnessed the murder, but not a single one of them called the police. This is a murder that took place over the course of half an hour, in front of dozens of witnesses, with no calls to the police.

At the time, this was baffling to behavioral scientists. No one could explain how that many people could witness such a thing and not help her.

No one except the killer. When asked why he would risk doing that in front of so many witnesses, he replied ‘I knew they wouldn’t do anything, people never do’. Obviously he didn’t know why, but it turns out he was mostly right.

The widespread publicity around this story sparked research into what became known as the Bystander Effect.

A quick side note: While researching this article I was surprised to learn that the story as I’ve related it above (and as it’s depicted in most descriptions) is not entirely accurate. While that is what was reported by the NYT, and what sparked the research, later investigations showed a very different picture.

There were probably closer to 12 witnesses, none of whom saw the whole attack. Most couldn’t see the attack at all, they only heard what sounded like a domestic dispute.
Only 1 witness saw that she was stabbed in the initial attack, and I couldn’t verify if that person ever called the police.
The police were called after the initial attack, but were only told a woman was ‘beat up, but got up and was staggering around.’ They didn’t respond.
After the second, fatal attack, the police were called and arrived within minutes.
One witness was already there comforting Kitty even though she couldn’t have known that the attacker had left.

While this case is not exactly accurate, it is the story used in pretty much every social psychology textbook, as it’s a very simple (and extreme) description of the Bystander Effect.

The Bystander Effect Link to heading

Let’s say you witness a tragedy: a car accident, a violent domestic dispute, or even something more mundane, like a child scraping their knee. If you’re the only witness, you’re probably going to do something.

But if there are lots of witnesses, you’re less likely to get involved.

And that makes sense. If 10 people watch something happen, it usually just takes one person to help, so 90% of the time you don’t have to do anything at all. Right?

That certainly sounds true, and in some ways it is. But when everyone feels the same way, that someone else will probably help, then nobody will act. So counterintuitively, if you fall and hit your head it might be safer to do it in front of 1 person than in front of 10, and not just because of the embarrassment factor.

When there are more people present, it’s easy to look around and think ‘oh, no one else is doing anything, so I don’t have to either.’ And that’s the problem of the Bystander Effect.

There are a few reasons to explain why this happens, the big ones being:

Diffusion of responsibility. You’re less likely to take responsibility for action or inaction when others are present.
Group cohesion. Members of a group are more likely to stick within the group than break out of it. If nobody else is doing anything, you won’t want to break the mold.

It’s an interesting effect, and there are all sorts of neat social psych experiments showing how we react to it. But there’s no need to go read social psychology papers to see it in action (you probably don’t find those as interesting as I do).

What Would You Do? is a prime time TV show on ABC that has been running for 7 seasons so far. The entire premise of the show is to set up some scenario in public and see if the bystanders respond, all recorded on hidden cameras of course. They mostly try to test various public prejudices (e.g. have a black male steal a bike in a public park and see if anyone responds, then do the same thing with a white female and compare the responses) but at its core it is an examination of the Bystander Effect.

(If you’re curious about the above scenario, the black male was reported immediately every time they tried it, but some of the bystanders actually helped the attractive white woman steal the bike, even after she told them she was stealing it.)

If you find it hard to believe that you wouldn’t respond in an emergency, watch that show sometime, I guarantee it will change your mind.

So What Would You Do? Link to heading

A few months ago I was vacationing with my family in Savannah, GA. Savannah has a relatively small and walkable historic district so we spent a lot of time walking around the city.

At one point as we were walking together we witnessed a car accident. At least one person was injured, but it didn’t look life threatening. Not counting the people involved there were maybe 5 or 6 people there as it happened.

My mother called 911 immediately, but I’m not sure if anyone else did, including the 6 or 7 other people who walked over to see what was going on. A couple other people were on the phone but they may have been on the phone beforehand.

Now my mom did the right thing. She saw that no one next to her had called 911 yet, so she did herself. Good job Mom!

Because of where everybody was standing on the street, several of the witnesses had no way of knowing if anyone else was getting help but still did nothing except watch. They assumed somebody else was doing it. In fact, I’ll admit that that was my first instinct too, even though I really should have known better.

The truth is it takes a lot of training to make sure you’re going to act correctly in an emergency. EMTs, nurses, and flight attendants are known for their cool-headedness in emergencies because they’ve been trained for it. You probably haven’t, so you’re probably going to react slowly in a real emergency.

In most cases, the hardest thing to overcome will be your natural inclination to stick with the crowd.

I won’t pretend to be an expert at dealing with emergency situations, but here’s my 2 cents worth of advice on dealing with the Bystander Effect in an emergency.

If you are the one that needs help Link to heading

Perhaps the most useless thing to do if you need help and are surrounded by people is to yell ‘someone call 911/help me/etc’. It puts the responsibility of taking that action on everyone there, playing right into the hands of the Bystander Effect. So don’t do that.

Instead, single out 1 person from the crowd and give them specific instructions. More specific instructions are more likely to elicit a response. ‘Come here’ or ‘call 911’ is much better than ‘help me’.

By singling out 1 person from the crowd, the diffusion of responsibility that cripples the crowd is gone. That one person is now responsible for providing help, and it could make all the difference for you.

If you are witness to some emergency Link to heading

The first researchers to demonstrate the Bystander Effect (John Darley and Bibb Latane) noted that bystanders go through five stages of reacting to an emergency.

Notice that something is going on
Interpret the situation as being an emergency
Determine their degree of responsibility
Determine the form of assistance
Implement the action choice

Step 3, the degree of responsibility felt by each person, is the tricky one; that’s where the Bystander Effect will get you. If other people are there you will have a smaller degree of responsibility.

But you know this now. You know that your brain is kind of stupid, and doesn’t always do the right thing.

And knowledge is power. If you ever catch yourself going through these steps in an emergency, just ignore everything that tells you that you don’t have much responsibility. Skip calculating step 3 entirely, always just assume that on a scale of 1 – 10 your ‘degree of responsibility’ is stuck on 11.

If you recognize it’s an emergency ask yourself ‘What do I need to do?’ instead of ‘Do I need to do anything?’.

Obviously the real difficulty is actually recognizing you’re in that situation, but unfortunately a blog post can only help so much with that.

Just try to remember to be bold, and unafraid to go against the crowd. One day you may just save a life.

The Future Self: Building a Better Bucket List

Thu, 12 May 2016 00:00:00 +0000

I have a problem with traditional bucket lists.

Most people make a ‘bucket list’ at some point in their life. It’s simple in concept; you sit down and make a list of all of the wonderful things you want to experience before you die. There’s certainly nothing wrong with that, it’s great to have a list to remind you of all of the things you dream of doing.

The problem is that the ‘bucket list’ that most people end up making is woefully incomplete.

I build my version of a ‘bucket list’ not just as end goals, but as a living document for the direction I want myself to go. An all-encompassing description of what I want to do and what I want to be like.

Unlike the usual ‘bucket list’, I intentionally don’t plan on finishing everything on it. In fact, many of the things on my list can’t be crossed off. Not everything in life can be whittled down to a checkmark.

Also crazy to me is this idea that people only make a list of things they want to do. A list of goals and travel locations and lifestyle milestones does not define a person, and is a very small part of what you actually want for yourself. Having visited the 7 wonders of the world doesn’t fundamentally change your everyday experience.

So my version of a ‘bucket list’ is a description of a new version of my self. Last week I talked about the distinction between your Real Self and your Ideal Self, and this vision document fits in nicely with those concepts: I call it the Future Self.

The Future Self Link to heading

My Future Self document is a description of where I want to go in the future. It’s not a list of end goals, though that is a part of it, but instead a vision of the type of lifestyle I want to have, the experiences and abilities I want to have, and the type of person I’d like to be.

To be fair, maybe other people have always seen a ‘bucket list’ this way; I’m certainly not claiming that this is an original thought. Rather, I think that most people make the mistake of seeing a ‘bucket list’ one-dimensionally, as literally just a list of things you want to do before you kick the bucket, and hopefully I can convince some of those people to broaden their horizons a bit.

Ok, I’ve been going on and on about this for a bit too long now, what exactly makes it different from a ‘bucket list’?

(Slightly) Different Contents Link to heading

Your Future Self is obviously going to be very personal, and it’s going to take some time for you to figure out exactly what you think it’s best to include. I tend to think about them in terms of 4 broad categories:

Goals and milestones to achieve.
Knowledge or skills to master.
Habits or activities to do regularly.
Character traits to embody.

Maybe you don’t find all of those types of things useful to write down. Perhaps you don’t care what type of person you are so long as you reach all of your other goals in life.

That’s ok, if you want to be a narcissistic billionaire go right ahead. But personally I’d rather be a better person than have a slightly longer number in my bank account, and writing that down in a place I’ll revisit keeps me mindful of that fact.

There’s one thing you should be wary of when deciding what to include. For many people, a ‘bucket list’ turns into ’the 50 places to see before I die’. I hate that for two reasons: first, it will never live up to your expectations (see Paris Syndrome), and second, actually going to all those places is enormously inefficient. In a world where climate change is real and caused by humans, flying halfway around the world to spend a day or two looking at pretty old things is at best a frivolous luxury, and at worst culpable malfeasance. If you’re going to travel, do it efficiently

Prioritization and Planning Link to heading

If your ‘bucket list’ has 100 things on it, how do you possibly get anything done?

Most people realize that if they have some type of project they’re planning for, things need to be done in a certain order, and some tasks are more important than others. To get anything done you have to organize it in a way that makes sense, sorting both by urgency and by importance.

Treat your Future Self just the same as you would any other project. Plan, prioritize and prepare accordingly.

Pick a few things you’re going to do soon, and lay out your strategy to get there. Add the steps you need to take into your task system and schedule them. Make progress now on the things you can do and keep the rest of it around for the future.

If you’re so inclined, set deadlines for certain things, or even schedule them in the far off future. Want to celebrate your 25th wedding anniversary in Paris? Put it in your calendar even if it’s decades away.

Use it to start planning your life intentionally. Don’t treat your life goals the way you’d treat a disorganized project; figure out what you really want and then make sure it happens.

How Do You Use It? Link to heading

How to use a ‘bucket list’ may seem like an odd topic, but bear with me.

Making a ‘bucket list’ and sticking it in a drawer never to be seen again is a waste of your precious time. If you’re going to take the time out of your day to sit down and dream of what you want to do and be, you should take care to actually move in that direction.

Like I said earlier, the Future Self is a living document, one that you need to look at and update regularly for it to be of any use. Personally I like to review it at least every month, though usually I’ll look it over at least briefly as part of my Weekly Review.

When you review it, don’t just read it and dream of a far-off future. Sure that’s part of it, but make sure you also look at it with an eye towards updating it. Remove things that no longer matter to you and add things that do.

Review it to look for things you can work towards. Do you have some extra time in the evenings to fill? Pick something off your Future Self list and get to work.

Most importantly, review it with an eye towards reminding yourself who you want to be. Take note of where you are now, and if you aren’t moving in the direction you want to make sure you change it.

Get Started Link to heading

Schedule some time now to get started. When you first set out to writing things down it may take a little bit of time. Set aside a half hour or an hour, and write down a list of things you want to do, things you want to try, and traits you want to have. Reviewing it will take much less time.

Make sure it’s in a place you can access easily. A notebook you carry with you, a saved entry in your favorite note-taking software, or a simple text file you keep on your desktop. You can use whatever works best for you.

If you need some ideas to get started, here’s the current version of mine. Feel free to borrow anything you’d like, but these types of things are highly personal so I expect yours will look vastly different very quickly.

The Ideal Self

Tue, 19 Apr 2016 00:00:00 +0000

Self-actualization sits at the peak of Maslow’s Hierarchy of Needs, and while you may not have heard the word it’s what you’ve been searching for out of life. To get there we need to internalize the differences between our ideal self and our real self, which is what we’re going to examine today.

I think Maslow put it best by defining it simply as “the full realization of one’s potential”, and of one’s ’true self’. In this context, ‘reaching your full potential’ doesn’t refer to reaching the end of your quest; finishing school, or getting that big promotion. What matters is that you are fulfilling your potential and your true self, today.

You don’t have to have ticked off everything on your bucket list, or even be at a fantastic place in your life. You just need to fully understand yourself and be satisfied with where you are in life.

Self-actualizers feel that they live a fulfilling life in a way that is true to themselves. And while their lifestyles may differ they do usually have some commonalities.

Realistic perceptions of themselves, others and the world around them.
Acceptance of oneself, others, and nature with all of their flaws.
Humanitarian. They tend to be driven by some mission bigger than themselves.
Independent. Reliant on their own experiences and judgment, not culture and environment.
Autonomy. They tend to be independent, self-reliant, and comfortable with working alone.
Profound interpersonal relationships. Deep, loving bonds with a few intimate friends rather than many superficial relationships.
Seek out Peak Experiences. Moments with intense joy, wonder, and deep meaning.

Personally, I think ‘self-actualization’ sums up my goals of personal growth quite nicely. And knowing the goal, I’ve been working on using the techniques from humanistic psychology to progress along the path to self-actualization.

The most useful concept that I’ve found is an understanding of the differences between my ‘ideal self’ and my ‘real self’.

The Ideal Self vs The Real Self Link to heading

When you think about yourself, you typically envision two different versions of ‘self’.

The real self. How you act and function in everyday life.
The ideal self. Your idea of what you wish you were as a person. What you believe you should be doing.

For most people, the ideal self and the real self do not match, and it is that disparity that generates internal conflict. Going about your life experiencing one thing but believing that you should be doing another is, to put it bluntly, not good. It’s the root cause of personal dissatisfaction and may even cause depression.

For the self-actualizer, these two visions of themselves match up. There’s nothing that they wish they should be doing that they aren’t actually doing.

To merge these two realities, we need to remain mindful of ourselves each day and understand what we want (or feel we should) be doing.

Become Mindful of the Real Self Link to heading

Being aware of how you actually act and being present in your life sounds like something that everyone obviously does, but it’s not so simple.

If someone tells me they want to lose weight and asks for advice, the best ’tip’ I can give them is to track everything they eat. Just knowing what you are eating, and how many calories you are consuming, encourages healthy choices. You’ll eat healthier without really trying.

The same should be true for the rest of your life. Understanding what you’re doing should help you make better choices.

The best way to do that, to stay present and ’live in the moment’, is to have some form of meditation practice in your life. For the uninitiated, mindfulness meditation is simply training the mind to be present as often as possible. To be aware of yourself and what you are doing throughout the day and avoiding the temptation to get lost in thought.

The truth is, you probably don’t realize how often you are lost in thought until you try meditating.

I mentioned meditation before during my Cold Shower experiment. I practice it (semi-)regularly using Headspace, which I highly recommend. I’ve also heard good things about Calm.com but haven’t tried it myself.

This won’t be the last time I recommend it, so give it a try today. It really will help you slow down and come to a better understanding of your own mind.

After you figure out what you are, you can then worry about figuring out what you want.

Understand Your Ideal self Link to heading

Too often when people think of their ideal self they don’t think of what they actually want for themselves today. Your ideal self is what you can be in the present, not what you want to be in the future.

Whether you’ve written it down or not, you probably have a ‘bucket list’ of things you want to do in your life. All the places you want to go, things you want to do, etc. And that’s great, it helps you define where you want to go in the future, but it doesn’t help you define your ideal self.

I’m going to talk more about the future self and bucket lists in my next article, but first w__e need to come to an understanding of what your ideal self actually is.

To come to know your ideal self, I have a short exercise for you to do. We’re going to visualize a day in the life of your ideal self. Feel free to write it down somewhere if you’d like, if you’re so inclined you can even review it each week in your Weekly Review, but spending a few minutes visualizing is ok too.

So picture this:

It’s a random Tuesday a few weeks/months/years from now, and you have a normal day of work ahead of you. What does your day look like?

When/where do you wake up?
Are you alone?
What does your morning routine look like?
What do you eat?
What do you have to do today?
Who are you doing it with?
What are your evening plans?
Are you going to exercise/cook/read/game?

That description you’re writing down, that image you’re connecting with, is your ideal self. It’s not some fictionalized, grandiose image of yourself in the future, it’s how you want to be right now.

That being said, any answer is ok so long as it’s what you truly want. Personally, my answers are pretty mundane.

Waking up early next to someone I love. Spending most of the day in solitude focused on challenging, fulfilling Deep Work. Taking time for myself to exercise my body and stretch my mind. Creating tasty, healthy food for myself and any close friends that happen to be around. Working on that personal side-project in the evening.

Everyone has their own flavor of course, but I’d bet that most people aren’t all that different. Maybe you want the hectic lifestyle of a corporate ladder climber or to be a jet-setting titan of industry, but it’s more likely you only think you do. Being busy isn’t a badge of honor.

Once you have this detailed understanding of your ideal self, you can start to note the (often small) deviations you take throughout the day that throw you off the path. And by remaining present and mindful of yourself throughout the day you can make adjustments to stay on track with how you want to live your life.

Next week I’ll talk about the future. For now, connect with yourself, meditate, and move just a little bit closer to self-actualization.

Image By FireflySixtySeven [CC BY-SA 4.0], via Wikimedia Commons

Education Reform

Tue, 05 Apr 2016 00:00:00 +0000

Ensuring that every child has access to a quality education is one of the most important things we can do as a society. Unfortunately we seem to be pretty bad at it.

And I’m not just talking about the U.S. (which ranks about average among developed nations, while spending much more per student).

Every school system is stuck in the past. It’s not entirely the fault of those working in it, but it does need to be fixed. It requires a massive overhaul of the system, changing the way we teach students and giving more power to individual teachers to help the kids that need it most.

I have an (unoriginal) idea for a way to revamp the education system, make sure the best teachers are well-compensated and for all kids to get the same access to education, regardless of their parent’s income.

It’s simple, the teachers should just not teach.

That’s it. Case closed. Problem solved.

Uhh, What? Link to heading

I get it. You’re probably asking yourself why that would help. Teachers are supposed to teach their students.

But the problem is that there’s no guarantee that your teacher is any good, we haven’t found a great way to figure that out. Observing teachers doesn’t work, because you can’t observe every teacher every day.

Grading teachers based on the performance of their students is a good idea in theory, but terrible in practice. It leads to teachers viewing poorly performing students as dangerous to their jobs, which is the exact opposite incentive we want to give them. We don’t want teachers resenting poor students; those students should be the ones getting the most help.

All you can do is hope that the school your kid goes to has great teachers. Though if you’re willing to buy a more expensive house you can increase your odds; school funding in the U.S. is largely supported by property taxes, so if you live in an expensive area then your schools will be better funded.

But there’s no reason to settle for that. I can teach Algebra just as well as the best Algebra teachers in the country. Most other subjects too, and I wouldn’t even have to teach.

See, I’m really just not very good at lecturing. Lesson plans, explaining complex things to tiny humans, it’s all very difficult. So I don’t think I’d bother.

I’d just get somebody else to do it.

All I’d have to do is find video lectures of somebody else teaching the subject. After all, a video of the best Algebra teacher in the country isn’t that much different than the real thing.

Of course I would certainly need to know the subject. If any student had trouble I could work with them one on one to help them catch up. But since I wouldn’t need to waste time lecturing, I’d be able to work with the students that need help all day long.

Optimization Link to heading

One thing you should know about me, I hate unnecessary work. There’s no reason to spend 2 hours working on something when you can get the same result in half the time.

So I don’t understand why every year, in thousands of classrooms across the country (millions around the world), a teacher plans out and gives a lesson to their students on why 2 + 2 = 4. Or explains to their students why Pluto isn’t a planet.

That information isn’t changing (usually). It isn’t different from school to school.

So why the hell do we make teachers waste their time teaching it?

If instead of giving a lecture the teacher could direct the students to watch a video, it would free up hours of their time each week. So not only is it better for the students, it’s better for the teachers.

Higher Quality Teaching Link to heading

Perhaps the most difficult part of being a quality teacher is knowing how to teach a group of kids with the same lesson.

Different people learn best in different ways. Some people are visual learners, some audio, some tactile, etc. Each kid may have a different style that they work best with: some of the kids in class may learn best if they just read the material, some if they hear it explained succinctly, some may need to be hands on with everything.

The real value in a great lecturer lies in their ability to cater lessons to all of their students, and all of their diverse learning styles. That is really hard. And for some strange reason, we make every teacher do this every time they teach a course, even though it’s the same lesson.

That’s just stupid.

If instead we have a managed set of video lectures, it is relatively easy to make sure they are high quality. We can have a centralized group of highly skilled people whose only job is to create the best lectures possible.

Naturally we’d give students access to these lectures at any time, so if they have trouble with a lesson they can always just watch it again.

No longer would you have to worry about if your kid went to a good school or not. Every student would have access to the same education.

And even though the lectures would be standardized, the freedom this gives to teachers would allow them to become much better at teaching the outliers in their subjects. Advanced students can work ahead and students that are behind could easily get help. Without the need to worry about lectures, a great teacher can become a great tutor to all of their students.

In Practice Link to heading

Interestingly, this level of catering to the students has already been tried on a large scale: homeschooling. In the U.S. today, there are over 2 million children being homeschooled.

If public schools started using taped lectures they would look a lot less like they do now and far more like homeschooling. The lesson plans could be better catered to the individual student, and they’d get more one on one time with the teacher.

And homeschooling, if you didn’t know, is far more effective than public schools. Which seems obvious, a homeschooled kid can spend more time on the subject they struggle with and less on the ones that come easily. A public school can’t do that yet.

Homeschooled children perform better than their peers on standardized tests, fare better in college, and despite most assumptions they have better social skills than their public school peers. Most tellingly, a study of homeschooled students showed that the performance gap between the children of high and low income families virtually disappears, and the racial gap is reduced significantly.

[I didn’t include it here due to it’s size, but here is a great infographic comparing homeschooling to public schools.]

Those studies are also 10-20 years old, when homeschooling was more difficult than it is today and public schools were largely the same.

The truth is, today I could homeschool a kid and give them a far better education than our broken education system. There is absolutely zero reason to send them to a public school if I want them to reach their full academic potential.

But we can change that. All it takes is a bit of investment and a willingness to challenge the status quo.

Today Link to heading

In some ways, the education system is already going in that direction. There have been a few limited cases where schools have experimented with ‘reverse schooling’ or ‘reverse instruction’, where the teacher assigns video lessons for homework and helps the students work through problems during class. But it astonishes me that it’s used so rarely even though the resources are already available.

Online sites like Coursera or Udacity already have full courses that you can take (most of them free too). MIT put most of their courses online and available for free years ago. But those are all for college level coursework.

Khan Academy is the largest resource I know of for this type of schooling at the K-12 level. For the past several years, Khan Academy has been building the resources to teach a variety of subjects using taped lectures.

Math is the easiest thing to teach in this manner, so that’s what they did first. They’ve built out lessons and practice problems to teach someone everything from basic arithmetic to college level calculus with no gaps. Practice problems are generated programmatically so you can do as many as you need, and you can check progress every step of the way. If a teacher wants to use it to teach a classroom of kids, Khan Academy has all the resources necessary to teach them and monitor their progress.

A math teacher can point their students to Khan Academy and they don’t have to worry about lesson plans again. They can focus all their time on helping the students who need it, and Khan Academy will even identify those students for them.

They also have lessons on science, economics, the arts, and computing. If you’re looking for more, another good resource is Crash Course on Youtube, which has been making lessons on everything from World History to Philosophy to Astronomy.

There are lessons available for free on almost every subject. All you have to do is search.

The Future Link to heading

Of course there are going to be issues with getting there. Individual teachers can’t take the initiative and do it themselves, since in the current system it would probably be seen as them not doing their jobs. Much of this change needs to come from the top down, and that only happens when we start to re-think the status quo and focus on effectiveness over tradition.

Look, today I could teach a kid far more effectively than public schools do. I could tailor their learning experience so they could advance just as fast or as slow as they needed to.

With the tools we have today the public school system could do the same, it just takes a mindset shift and a concerted effort from some smart people.

The public school system is a horrible failure in many ways, and if you can manage the logistics of it then homeschooling your child will already provide them with a much better education. The statistics prove it.

They can learn economics from a hedge-fund manager turned teacher (the founder of Khan Academy), calculus from an MIT professor, and astronomy from an actual astronomer.

And that’s all available for free, today.

If the public school system doesn’t adapt quickly, the disparity will become even greater; I won’t be able to put my kids into the public school system in good conscience.

Given the choice between an underpaid, overworked high school teacher and the most eloquent educators in the world, I’ll choose the latter every time. All it’ll cost me is the price of a cheap laptop and an internet connection, both of which I already have in my shitty apartment.

It baffles me as to why the U.S. spends more than $5,000 a year per student to do worse than that.

Photo by Malate269 (Own work) [Attribution], via Wikimedia Commons

Fake People Are Better Than You (or WWBD?)

Tue, 29 Mar 2016 00:00:00 +0000

Think of a fictional character that you admire. It could be from a movie, a book, or maybe your favorite video game.

Pick a character that brings you joy. Someone who is entertaining to watch and read about. This character should have a life that is a great story, since that’s what the movie/book/game is about.

Most importantly pick a role model, someone who you want to emulate. Someone who is happy, successful, and a good person.

Got someone in mind?

Good.

Now here’s my question to you. If that person was in your shoes, with all of their character traits intact but with all of your knowledge, experience, skills etc., what would they do?

Do you think they’d act any different from the way you’d normally act? Do you think they’d stay locked in the rut you’re currently in, going about the same day to day routine?

Of course not, that’s why you admire them in the first place.

The image you’ve created of this fictional character wouldn’t do the same thing you’re doing. They would do something interesting, something epic. They would break out of the daily monotony and create a remarkable story.

They would embark on a training montage to be the best [warrior/athlete/chef/author/fashionista] in the world.

They would spend their free time honing their talents in order to defeat their enemies, whether that enemy is The Capital, Voldemort, or a Sith Lord. All of their energy dedicated to a single purpose, their ultimate victory.

What they certainly wouldn’t do is spend hours a day watching stories about other people, yet that’s what Americans do. According to the American Bureau of Labor Statistics, this chart below is the breakdown of time people spent enjoying leisure activities.

[Note that this leisure activities split was determined via a survey and interviews, so I expect that the ‘Watching TV’ and ‘Playing Games’ times are an underestimate of reality. I’ve seen other sources estimate as high as 4-5 hours of TV a day per American.]

I mean honestly, can you imagine your favorite character sitting down and wasting their precious time like you do? I highly doubt you’ve read or watched a story about them doing so.

That free time is time that they could spend doing something.

We waste all of this time living in fictional worlds that we don’t take the time to improve our own lives, and that’s the ultimate problem I want to address with this exercise. Let’s use these fictional role models to combat the issue that they in part create.

Akrasia Link to heading

That feeling you get when you’re watching TV but you know that you should be doing something useful is called akrasia.

Akrasia is ’the state of acting against your better judgment.’ It is sometimes described as the lack of self-control. And it’s more than just procrastination.

It’s there every time you eat one more cookie, or procrastinate on a big project. It’s the hesitation you feel when you’re doing something you know is bad but you do it anyways.

Once you learn to recognize when you are behaving akratically, you can learn to…well…stop. You can do that with your limited willpower, or you can cheat and do it by changing your perspective.

A Fresh Perspective Link to heading

“True character is revealed in the choices a human being makes under pressure – the greater the pressure, the deeper the revelation, the truer the choice to the character’s essential nature.”
― Robert McKee, Story: Style, Structure, Substance, and the Principles of Screenwriting

That quote is from a book on story creation. It’s advice to writers on how to create great characters that their audiences will appreciate and connect with.

But doesn’t it make sense for real life advice too?

There’s a lot to take away from fictional characters that can be beneficial in real life, and you certainly don’t have to read books on story creation or the hero’s journey to apply it.

Characters are simplistic, two-dimensional representations of reality. They have a small number of defining characteristics that they embody or seek to embody over the course of their story arc. While a simplistic character can sometimes be too simple for the purposes of a story, for our purposes that can actually be a good thing.

Take your character from above. In fact, take any person you look up to even if they’re not fictional. You could use a mental model of Elon Musk just as easily as a mental model of Gandalf.

Now ask yourself this: If your role model character was in your shoes, right now, what would they do differently?

Often I find that it’s easier to think of what someone else would do than to think about the situation directly. Mental models of other people are simpler than reality, so analyzing complex situations through their lens can make those difficult decisions easy.

Over time, you should try to replace this mental model individual with Future You, your mental model of yourself in the future. If you already have a clearly defined model of the Future You that you want to be, use that instead.

Painting issues in this way can be useful for cutting through to the core of a decision. Your role models don’t quit when things get tough, they don’t compromise their virtues for personal gain, they don’t keep smoking when they know they should stop.

They simply do what needs to be done according to their values, simplistic as they are.

So the next time you’re pouring yourself another drink, or pulling out another cigarette, or procrastinating on a big project, consider this: What Would Batman Do? (WWBD?)

I’m fascinated by stories and their implications. Why people (myself included) prefer to escape into a story instead of staying put in their own life.

After all, the people you look up to in stories usually have no need to do that. Ever seen Luke Skywalker read a fiction book?

Why must we escape to new Galaxies, or fake histories, or real life other people instead of spending time in our own lives?

I’ve always thought it would be fun to have a ‘storybook’ style life. Everything is straightforward, there’s one ‘Big Bad’ to compete against and thus there is little ambiguity in the everyday decisions to be made.

Reality is obviously different. Usually there’s not a ‘Big Bad’ and the options are limitless. We’re in an open world world and there’s no limit to what we can do.

This website is supposed to be about that to some extent. Using science to engineer a remarkable life, an interesting life, a lifestyle chosen and designed because you want it.

The past few months I have been researching and writing about useful knowledge, mental models, and techniques for self-improvement. I’m attempting to slowly build a toolset for lifestyle design that anyone can use with some effort.

What’s missing is the story.

To that end I’m going to begin sharing my story. I’m not saying that I possess a remarkable story that should be emulated, quite the opposite really, but I don’t intend to talk much about the past.

What I intend to document is the story going forward. The story of using myself as a guinea pig for implementing this toolset of knowledge. I’ll publish my ‘N of 1’ experiments that I carry out on myself, and share the preparation and results of any adventures I may go on.

The biggest changes and greatest moments of my life have come from experimentation and adventure, and I plan to make some more memories.

Quite possibly, this will be a story with a lot of failures. But that’s ok. The only people who have never failed have never tried.

If you’d like to follow along with me, feel free to subscribe to the RSS feed or via email at the top of the page.

Delusional Beliefs

Tue, 22 Mar 2016 00:00:00 +0000

Today I’m going to talk about why people believe stupid things. Like really stupid things. Things that are so clearly wrong that these people must have something wrong with their brains.

By that I mean that this is another article on Cognitive Biases. And by ’these people’ I mean everybody.

Since the US in currently in the midst of its presidential primary election season, beliefs and the art of persuasion has been on my mind. The sheer distance between what each side of the aisle believes is mind boggling, which if you think about it is a bit odd.

We’re all exposed to the same information, the same news articles, the same facts. And yet, we come to vastly different conclusions.

Today I’m going to try to explain why.

Confirmation Bias Link to heading

The first of the biases I’ll cover in this article, and likely the most well-known. The other effects that I will discuss are types of confirmation bias.

Confirmation bias is the tendency towards preferring what we already believe. While we’d like to think that we get exposure to all different sides of an issue, we really don’t.

Because of your confirmation bias, you will tend to seek out information that confirms your beliefs. Few people watch both Fox and MSNBC, as the common view is that they are biased to the right and left respectively. (You can’t escape this even if you try, as Google personalizes their search results based on your personal interests.)

When you see new information, you will interpret that more favorably for your currently held beliefs. You’ll make excuses for the things that contradict your view and take supporting information as gospel.

You will actually remember the information that confirms your previously held beliefs better than contradictory information. That sounds nuts, but if you’ve read my article on False Memory it shouldn’t sound like much of a stretch. By remembering supporting arguments better than opposing ones, then from your perspective your views will always be the most supported.

This causes us to become very insular in the information we pay attention to, and the people we associate with. You stop reading and watching things that don’t confirm your viewpoints. You stop exposing yourself to other information because it’s uncomfortable. And it’s difficult to be friends with someone when they hold a belief that you honestly believe is delusional.

You may like to claim that you’re open-minded, but you’re probably not. Without breaking through this bias you are destined to hold the same beliefs forever.

Backfire Effect Link to heading

One of the effects of the confirmation bias is…surprising. And surprisingly prevalent, so I need to call it out and explain it.

When presented with evidence against their beliefs, some people will change their views in such a way as to strengthen their already held beliefs. This is beyond just ignoring the new information: presenting a liberal with facts supporting the conservative argument will push them to become more liberal, not more moderate.

I can’t overstate this enough. Someone who believes that the Earth is flat will, when shown a picture of the spherical Earth as seen from space, react by throwing out the evidence and believing even more strongly that the Earth is definitely flat.

It defies logic, but you usually can’t change someones beliefs by facts alone. I can sit around all day and explain to you why the Earth is clearly planet-shaped, but if you were firmly locked into your belief that it was flat when we started, you will only be more entrenched in your belief when we finish

As an example a little closer to home, here is the study that first described the backfire effect (as far as I can tell at least) [PDF]. It describes how conservatives were presented with a fake article containing a quote from George W. Bush claiming the existence of weapons of mass destruction in Iraq. Some of the subjects were shown a factual correction pointing out that the quote was false and no WMDs existed. The people that read the factual correction were measured afterwards to hold stronger beliefs that the initial quote was true, despite the article pointing out the mistake.

Their beliefs were strengthened by a factually correct argument against them.

Recognizing Tactics of Persuasion Link to heading

Watching politics allows us to see persuasion techniques in action. You can observe politicians that agree with your beliefs and those that disagree, and watch how the best of them work to change your belief to their side.

Importantly, you should observe how you respond to the arguments as well. Do you tend to give more weight to the arguments supporting your views?

Probably. So politicians try to use other means to persuade you to their side. When you start to look at them objectively, they stratify into a few different categories.

Some politicians are terrible, and their main tactic used are ‘gotchas’. Obviously that won’t work, that’s pure divisiveness; it will secure your base but not win over anyone. It’s like trying to convince an Englishman that the royal family isn’t important by insulting the queen. You just don’t do it.

A better politician will try to convince you that their position is defensible by using facts. Most would think that this should work, but as we’ve seen above it doesn’t. People ignore facts in favor of previously held beliefs.

A great politician already knows those don’t work. So they use other means.

A great manipulator* focuses on convincing you with rhetoric instead of facts. Often they don’t even try to convince you of specific issues, they just work to get you to believe that they themselves are trustworthy. Once they’ve given you a new belief, (how trustworthy and capable they are), then they tell you what the correct views are. If your view that they are trustworthy and capable is stronger held than your belief in whatever it is they’re trying to convince you of, they’ve won.

*Yes, manipulator has negative connotations, but I don’t intend it that way.

They know that people hear what they want to hear, so they employ strategic ambiguity to make statements on divisive topics that everyone would agree with. Here are some examples describing how Donald Trump is using that strategy.

They repeat themselves over and over because the more times you hear it the more likely you are to believe it’s true. That’s the Illusory Truth Effect, another cognitive bias.

They use a limited vocabulary to talk to the public, because using simpler language in an argument sounds more persuasive.

If you know what to look for, watching politics is like watching a competitive sport. It’s a competition to see who is the best manipulator.

My Beliefs Link to heading

I am of the belief that this is a problem.

I don’t necessarily have a problem that others succumb to these tendencies, but I don’t want to be subject to them myself. I don’t want to be convinced with rhetoric and manipulation; I want my viewpoints to be closer to objective reality. Sound science and defensible logical inference should be the base upon which I build my views and beliefs.

Hopefully you feel the same.

Combating it is difficult though. You need to pay attention to when you have no real facts backing up your argument. You need to recognise when you are experiencing cognitive dissonance: believing two contradictory things.

Those are probably signs you need to take a step back and reevaluate.

Cracking Your Naive Realism Link to heading

The whole point of this article is to try to break through your perception of Naive Realism. In fact, that’s really the point of my whole Cognitive Bias series.

Naive Realism is the belief that we see the reality around us objectively, and that people who disagree must be uninformed, irrational, or intentionally biased.

Hopefully by understanding how you (and others) can believe in something delusional while still being a rational person you can start to challenge your long-held belief that you are always correct.

Homework Link to heading

So here’s a question for you. And I want you to really think about it.

What are you convinced of that may be wrong?

I can guarantee you have a viewpoint that is blatantly opposed to the viewpoint of some large group of people, and those people can’t all be delusional.

Perhaps you believe that climate change is not man-made, despite the scientific consensus. Perhaps you think that the Earth is ‘planet-shaped’ despite all evidence to the contrary. Perhaps you think vaccines are safe, despite this website describing how vaccines cause autism (with sources!).

Maybe you think that democracy is the best form of government, or that the U.S. is one.

The thing is, what if you’re wrong?

If you’d like to read more about divisiveness in politics and possible solutions to the problem, check out The Centrist Manifesto.

Image courtesy of Ryan McGuire.

The Pareto Principle

Tue, 15 Mar 2016 00:00:00 +0000

120 years ago, an Italian economist named Vilfredo Pareto discovered a similarity between the landowners of Italy and the peas growing in his garden. This observation led to a now common rule of thumb in business known as the Pareto principle.

You may have heard it called the 80-20 rule.

The Observation Link to heading

Pareto made his initial observation by looking at the distribution of land ownership in Italy. What he found was that 80% of the land was owned by 20% of the people. Not a surprising observation in itself, but when he looked at other countries, he found a nearly identical distribution of ownership.

In his garden, Pareto observed that 20% of his peapods produced 80% of the peas. An oddly similar distribution. Why would these unrelated observations be so similar?

In fact, there are examples of this ratio from every facet of life.

The richest 20% of the world takes in 82% of the income. [Source]
In the United States, 20% of healthcare patients use 80% of the resources.
Microsoft reports that 20% of their known bugs are responsible for ~80% of their crashes. [Source]
and so on…

As I’m sure you’ve guessed, there’s nothing weird going on here. There’s no black magic forcing this into place. The reality, obviously, is much more mundane.

Statistics Link to heading

Ok, maybe it’s a little bit like black magic.

This effect comes about due to nothing more than a power law relationship between the two quantities, where “a relative change in one quantity results in a proportional relative change in the other.” Skipping the math, what this really means is that the two quantities look like this if you graph them against each other.

[Image courtesy of Wikipedia’s Power Law article]

You have likely seen a graph or two with this type of distribution before. The green part of the graph represents only 20% of the x-axis but accounts for 80% of the total area under the curve.

In actuality, there isn’t anything special about this specific ratio. ‘The 80-20 rule’ as a saying is easy to remember, but it’s just the split that arises from a standard distribution of results. It could just as easily be ’the 80-10 rule’, the gist is the same: a small percentage of actions produce a disproportionately large portion of the results.

What This Means Link to heading

This rule is well known in the business world for its applicability as a rule of thumb for optimization. It’s valuable because it doesn’t just apply to one thing; as we’ve seen above it applies to many different areas.

If you’re a knowledge worker, I can almost guarantee that you spend a small amount of your working time actively working on things that are responsible for the majority of your results. Your job performance depends on getting great results at a few particular things and getting by on the rest.

Most of the emails you send are probably unimportant, but a few of them may be vital. If you spend all day responding to email (or in meetings) you’re probably doing something wrong.

Similarly, most of the studying that you do is probably worthless. If you’re trying to learn a new language, for example, you shouldn’t be spending time memorizing esoteric vocabulary. Native English speakers probably have a vocabulary of ~15,000 words, but the most common 1,000 words account for greater than 80% of the spoken language. The top 100 words are a full 50% of all English spoken. If you’re bothering to learn the word for ‘apple’ before you learn those, you’re doing something wrong.

Learn the grammar and the most common words first and you’re on your way to learning a new language. All it takes is a small amount of research and planning.

OK, So What? Link to heading

Amusingly, while the upper part of this article is good background it isn’t entirely necessary to our conclusion. While I spent a while expounding upon why it’s a thing, the entire article can be summarized in 2 sentences.

Most of the things you do have little effect on your desired outcome. A small percentage of your actions (maybe 20%, maybe less) contribute to the majority (80%+) of the results.

This leads to the single most useful rule in productivity: Think about the actions you take before you do them.

Figure out what has the largest effect on the outcome you want, and reduce everything else. Ruthlessly eliminate the work that is inefficient and ineffective at getting to your desired result. There are better ways to spend your time.

This topic is a core principle of the best business book I’ve read in the past year: Deep Work by Cal Newport (who also runs the Study Hacks blog). The entire book is about the importance of maximizing time on your most impactful work, and on strategies you can take to do so. I highly recommend it.

Misplaced Fear

Tue, 08 Mar 2016 00:00:00 +0000

I’ve noticed a disturbing trend recently. Not that it’s a recent trend, I’ve just begun to notice it.

People are irrationally afraid of things that they will likely never experience.

As an example, let’s look at terrorism. More people seem to be afraid of getting killed in a terrorist attack than they are of being killed by cancer. That fear is mind-bogglingly irrational.

If you live in the western world, you are more likely to die from almost anything else than you are to be killed in a terrorist attack. Here are some statistics I’ve compiled from data about the United States in particular. I’ve rounded off most of the numbers since there tends to be a bit of ambiguity in the sources.

Since 2001, <4k people have died from terrorist attacks (The vast majority being the 2,977 people who died in the 9/11 attacks)
303 Americans were killed by religious extremists in the decade from 2004 to 2014
- 24 of those were on US soil

In the same decade…

100 people were killed by vending machines
500 people were killed by lightning
6,000 people died from autoerotic asphyxiation
300,000 people were killed by guns (the majority of which were suicides)
500,000 people were killed in car accidents
610,000 people died from heart disease…every year

If you look at it objectively, it’s obviously not something to worry about. But we still do.

It’s a fear of the unknown. A worry that you don’t know when or where the big bad evil person will come for you. That you could be going about your day and someone could come along and kill you just because they believe it’s the right thing to do. They might even believe in a perversion of your own religion, yet still want to kill you to support their own goals. It’s a scary thought.

But why is it scary? You’re 1000 times more likely to die in a car accident today than you are to get killed by a terrorist, but you’re probably not scared of that happening.

We’re too concerned with fear of the flashy things. Our minds focus on the things that are vivid and interesting, and not on the things that are most likely to happen.

It’s an irrationality, one that you should rigorously work to beat out of yourself.

What Should Scare You? Link to heading

Statistics are not trusted by a lot of people; they can be massaged to say just about anything. However, statistics viewed properly can reveal the truth.

If you find yourself scared of something that’s obviously irrational, like a terrorist attack, look at the statistics. What is the most likely thing that’s going to kill you? Obviously terrorist attacks are low on the list, hell, it’s below lightning. (Incidentally, while looking this up I learned that lightning only kills you 10% - 30% of the time, so lightning isn’t all that bad.)

Here’s a nice little graph I borrowed from Wikipedia that shows the leading causes of death by age.

To figure out what’s most likely to kill you, you need a little bit of Calculus. Since you’ve already lived to whatever age you are now, ignore everything to the left of your age group. For each cause of death, add up the area under the curve to the right of your age group and see which comes out to be the most likely cause of death for the rest of your life. Now this is a real challenge, so if you need to go review your old Calculus textbooks, I can wait.

Ok, now, raise your hand if you got terrorism. Anybody?

That would be pretty impressive, considering it’s not even on the damn list.

In fact, you’d have to be planning to kill yourself before 75 for you to get anything other than Cardiovascular Disease as your answer.

Your Heart Will Kill You Link to heading

I’m not trying to be depressing here, I promise I’m trying to help.

Part of what makes terrorism scary, as I’ve discussed before, is the feeling that you can’t do anything about it. You’re scared that somebody else will come and take away your opportunity at living for their own reasons. I hear you, I don’t want to get murdered either.

But luckily for most of us, that’s not going to ever be a problem.

Far and away more likely, your heart is going to give out. Or you’ll die from cancer (that’s the second one on the list by the way, “Malignant neoplasms”).

And these things, the things that likely will kill you, are preventable.

Not entirely, obviously. I’m not some crackpot running around preaching that cancer is curable by eating broccoli once a day (though to be fair I did point out that Cold Showers might help fight tumors, the key word being might). But you can reduce your chances of getting heart disease or cancer in the first place through lifestyle changes.

Even though you can’t cure them you can reduce your odds of getting them or delay the onset with relatively little effort. By acting now you might add years of healthy living to your lifespan.

How to Live Forever Link to heading

(As much as that heading is a joke, only 91% of all homo sapiens who have ever lived have actually died)

You already know what I’m going to say here, but I’m going to say it anyways.

The odds of dying from heart disease, cancer, type II diabetes, and Alzheimer’s can all be reduced through proper diet and exercise.

While everyone else is worried about getting killed by other people, people who pay attention to statistics are over here eating right and exercising. There’s never a guarantee in life, but taking care of yourself has the potential to add years of healthy living to your life.

In contrast, worrying about a violent attack is more likely to just increase your blood pressure and kill you sooner.

So don’t let the terrorists win. Eat your veggies.

The Anchor Habit

Tue, 01 Mar 2016 00:00:00 +0000

The fatal mistake made by almost everyone when trying to improve themselves is to take on too many things at once. You see this all the time in people’s New Year’s Resolutions.

I’m going to eat healthier
AND I’m going to workout everyday
AND I’m going to finish that knitting project
AND I’m going to journal everyday
AND …

It doesn’t work. Few people are able to force themselves to make all of those changes at once. If you made such a list as your New Years resolutions, tell me: Do you even remember the things you planned to do?

I’m betting the answer is no.

Luckily there’s an easier way. One that doesn’t involve the ability to use up an extreme amount of willpower.

The Ultimate Secret to Forming Habits Link to heading

Ok, here it is. The big secret. The one people buy all those fancy self-help books to learn. You ready?

When you want to form a new set of habits (or get rid of some bad ones) pick one, and only one and do that first. Do that alone for a minimum of 3 weeks. Then you can add another one.

If two of your habits complement each other, only then can you try to do two at once. For example, I talked last week about taking Cold Showers. Since I had seen that several other people reported it to have much the same calming effect as meditation I paired it with a renewed interest in a daily meditation practice, which worked surprisingly well.

Repeat until you’ve acquired all of the things you wanted. Or gotten rid of all the bad habits you’ve picked up over the years. Or until you’re dead, that works too.

Trying to expend your energy on too much at once depletes your willpower and makes you fail all of them. It just isn’t going to work in most circumstances.

So now you have a list of things you want to change about yourself, but you are only allowed to do one at a time. They all look so exciting…where do you start?

The Anchor Habit Link to heading

Introducing big secret #2, the Anchor Habit. I even capitalized it, so it must be important.

An Anchor Habit is a habit that helps you form other habits. One that helps you do better in your life just from that one single change. It is turbofuel for changing your life, and a base upon which you can grow a better you.

Wow, that sounded cheesy.

For me, the most important determination of whether I will have a good day or a bad one is my Anchor Habit. On the days I meet my habit, I am almost twice as productive as days that I don’t, and it is rare that I have a bad day when I do this one thing. For my life, it is far more important than any other single thing I do.

My prime Anchor Habit is good sleep and early rising.

If I wake up before 8 am (before 7 is even better) after a good 8 or more hours of sleep, I will have a good day. If I don’t meet both of those, then my day is a bit of a toss up. Either I’m too groggy to get myself to do what is necessary, or I waste time getting distracted because of my late start to the day.

Getting an early start to the day is my rocket fuel. I can immediately get time to work for myself before I have to start dealing with other people. I can get some solid work done during the early hours of the morning while everybody else is eating breakfast or still sleeping.

I’m usually not a very productive person, admittedly, but when I’m out of bed at 6 am with a full nights rest, that’s almost guaranteed to be the most productive day of the week. So when I get off track in my work habits, getting back on track is as simple as changing one thing: my sleep. Everything else I need to do follows from that.

Finding Your Rocket Fuel Link to heading

But that’s just me. Maybe you already have sleep dialed down, or maybe you have young kids and never get to sleep a full night anyways. Your Anchor Habit is probably something entirely different.

If it’s not obvious you’ll probably need to spend a little time trying things out or thinking about it. I promise it’s a worthwhile endeavor.

If you need help, take a look at your ultimate goals. I assume that you have a bucket list, or short term goals, or some habits that look cool that you’ve been thinking about taking up. Something of that sort. Even if you have a long list, I’m betting that there are actually very few themes. You likely have only a few different themes of things in your life you want to do or change: improving your health, traveling more, better personal relationships, success in your work, etc.

Each of these broad themes have one or two habits that get you 80% of the way there. For example

Want to improve your health? Upgrade your diet, one step at a time.
Want to travel more? Save up money and/or travel rewards points.
Want better personal relationships? Talk to your loved ones more often.
Want success in work? Work smarter (on the right things) then work harder (be more productive).

Hopefully in looking at your own list you can identify a common thread that you can build a base upon.

In my example, I am trying to be more productive in my professional life and my personal life, and I found that the best way to do that is just to get better sleep and start my day earlier. It sounds simple, but literally the most important part of my day actually happens the night before, when I choose when to go to sleep.

Don’t try to do everything at once. Focus on the most important of your habits, the Anchor Habit, and the rest will follow.

The Benefits of Cold Showers

Tue, 23 Feb 2016 00:00:00 +0000

For the past month I’ve been foregoing my usual steaming hot shower for a cold one. Not everyday, that habit is a hard one to break, but the majority of the time I voluntarily froze myself in pursuit of science.

I try a lot of crazy shit on myself, so let me answer the usual questions even before we get started: Yes, it’s difficult and uncomfortable. No, I’m not crazy. Yes, I have very good reasons. Yes, I’ll probably keep doing it. No, I never regretted my decision.

Ok, you got me, that last one was a lie.

Why Am I Doing This to Myself? Link to heading

Ah, the eternal question. It’s good to know the answer before you try doing something distinctly uncomfortable, like freezing your ass off, voluntarily.

With a good enough Why?, you can push through almost anything. The more painful something is the more important it must be. The more potentially beneficial.

Giving up your favorite dessert will help you reach your goal weight, but that’s pretty easy. Going through chemotherapy is much harder, but it might save your life.

The trials need to be worth it in the end.

Lucky for me, I don’t take cold showers because I woke up one day and decided to be a masochist. There are very good reasons for putting myself through that, too many to get to in this post even.

And thankfully, after several distinctly uncomfortable days, I’ve even started to enjoy it.

The Benefits Link to heading

There is an abundance of research on the benefits of cold showers. Much of it is on longer term exposure, but some has looked into cold showers in particular. Here are some of the most well-documented benefits:

Treatment for Depression Link to heading

At least one study has shown that cold showers are a potential treatment for depression. The theory is that due to the high density of cold receptors in the skin, a cold shower sends an overwhelming amount of electrical impulses from peripheral nerve endings to the brain, which could result in an anti-depressive effect.

Relieve Pain Link to heading

Cold hydrotherapy is known to reduce pain. It’s a stress-induced analgesic (pain reliever) for the same reason it is a treatment for depression. The heightened nerve signals ‘crowd out’ the pain signals, and the effect persists after the exposure.

More Brown Fat, Less Other Fat Link to heading

Brown fat, or BAT (brown adipose tissue) is a type of fat that burns energy and glucose to generate heat. It’s good fat, and you have a tiny amount of it, mostly concentrated in the neck/shoulder/upper back area. More brown fat boosts your metabolism, keeps you warmer throughout the day, and thus just like muscle it burns fat all day long.

Fat that burns fat. Cool.

Long term cold exposure stimulates the growth of brown fat. Each shower also stimulates those fat cells into action generating heat to warm you back up, so you are literally burning fat to keep you warm while you shower. I won’t overstate it though, this benefit is probably only a few pounds a year from cold showers alone.

Improved Insulin Sensitivity Link to heading

More brown fat improves your insulin sensitivity, which is a very good thing. Type II diabetes is caused by decreased insulin sensitivity. The authors of the paper above suggest that increasing your brown fat may be a promising therapeutic strategy for treating both diabetes and obesity. Even if you’re not concerned about diabetes, higher insulin sensitivity is still a good thing.

Reduces Fatigue Link to heading

Cold stress has been shown to reduce the level of serotonin in most regions of the brain, which would be consistent with reduced fatigue according to animal models of exercise-related fatigue. Source.

Better Immune System Link to heading

Acute cold exposure (like a cold shower) is used in Siberia as a preventative measure against illnesses. Of course, being Siberia, they just run outside in swim wear and dump a bucket of water over their heads. It’d be funny if it didn’t work but for those that practice what they call ‘dousing’, 95% go through the flu season without getting sick compared to 75% of the others.

I should mention that the example I have is on children aged 2 - 6. If a six year old can do it you probably can too.

Additionally, from this paper, ’there is accumulating evidence that daily brief cold stress can increase both numbers and activity of peripheral cytotoxic T lymphocyctes and natural killer cells, the major effectors of adaptive and innate tumor immunity.’ Basically, the paper hypothesizes that brief cold-water stress every day for months could enhance anti-tumor immunity and improve survival rates for non-lymphoid cancer.

Improve your cancer outcome just by turning the shower knob to the right instead of the left…maybe.

Keeps Skin and Hair Healthy Link to heading

Hot water dries out your skin and hair. Cold water closes your cuticles and pores, which can make your hair shinier and your skin look healthier. Pretty simple.

Increase Testosterone Link to heading

Cold exposure has been shown to increase testosterone production, at least in men. In addition to increasing libido, higher testosterone levels boost overall strength and energy levels.

And More Link to heading

For a whole host of other benefits, read through this medical article that cites many many other studies and reviews concerning hydrotherapy (water-based therapy). It’s not exclusively about cold exposure, but a large part of the article covers that topic.

My Own Experience Link to heading

Anecdotally I’ve experienced few of the benefits above (since it’d be a bit difficult to measure, and a month is too short anyways) but I know that the cold showers make me feel better. After taking one, I feel refreshed in a way that I don’t feel after a hot shower. I am noticeably warmer the rest of the day, so I’m more comfortable with a lower temperature in my apartment.

I also feel calmer and more aware of the present moment. It’s similar to the clarity that comes after a meditation session, in fact I’ve taken to doing my daily meditation after my shower most days to compound the effect. It seems to be related to the meditation practice in that it forces you to be aware of the present during the uncomfortableness of the shower, whereas in meditation the clarity of the present is done through focus.

From taking cold showers relatively consistently over the past month, I can say that I actually have started to prefer taking non-hot showers rather than hot showers. Occasionally I just want to take a hot shower and revel in the warmth, so I do, but most days I take a cool/chilly shower and occasionally a truly cold one.

How, You Ask? Link to heading

Taking a cold shower is the simplest thing in the world. Get in the shower, and turn it on to full cold. Make sure you’re standing under the nozzle, and just keep pushing through the shivering, hyperventilating phase until it passes.

Have fun with that.

While that might be a good test of fortitude to do occasionally, it sucks. It forces you to us a lot of willpower to go through with it, and I’ve found a much easier way.

Here’s the routine I’ve taken up for shower time:

[Optional] Warm Up. Taking a cold shower after getting warm, from a workout or just a few quick pushups, jumping jacks, or squats, is a lot easier than jumping in right out of bed.
Turn on the shower.
Get the temperature just cold enough for you to stand in without shivering. Over time you’ll be able to jump in to a colder and colder shower, so know your own tolerance.
Jump in and get wet. Only after you’re wet all over do you turn the temperature down more, it’s much easier that way.
While soaping/rinsing everything, continue to turn down the temp in little increments as you adapt.
Continue step 5 until finished washing.
If you still have a little time left, turn the temp all the way down and stay there until you adapt to it.

Keeping the temperature just under your comfort level promotes adaptation to the stressor, which is what we’re going for. After a month I am noticeably much faster at adapting to extreme cold and more comfortable starting out at a much colder temperature setting.

Eventually the goal is to be able to start on full cold and enjoy it, but it’s much easier to work up to it than to go full blast. I’m a big proponent of taking little steps in the right direction without going full bore and risking burn out. Habits that are painful are very difficult to start and stick with, and the protocol above makes this one easy.

The other thing that I do is timing. I want to take a 5 minute cold shower, but just setting an alarm would be boring.

So I just shower to music.

I listen to “Ain’t It Fun” by Paramore. The version on Spotify is 4 minutes and 57 seconds long, perfect for timing a 5 minute shower. Plus, hopefully the refrain of ‘Ain’t It Fun’ will sink in and condition me into believing I’m having fun. The official version on YouTube is here, but it is over a minute shorter.

Regardless, that’s just my choice. Go ahead and pick your own song(s) to listen to. What was very helpful for me during the first few painful showers was also having a set-up song to pick me up beforehand, and a finale song to cue me for when I finished. (I queued up “Fuck You” by Lily Allen to play when I was done so I could get good and mad if I wanted.)

A Warning: I am not a doctor, nor do I play one on the internet. Talk to your doctor if you are concerned about health complications. This is especially important if you have heart problems, since I do know that acute cold exposure can exacerbate existing heart conditions.

Photo by Pascal Montsma

False Memory

Tue, 16 Feb 2016 00:00:00 +0000

This is part of a series of articles examining Cognitive Biases. Go here to view the rest of the series.

The False Memory Bias has been on my mind recently due to an (un)fortunate binge-watching of Netflix’s documentary series Making a Murderer. The documentary covers the trial and conviction of Steven Avery for a crime he did not commit back in 1985, his release based on DNA evidence in 2003, and his subsequent trial for the murder of Theresa Halbach in 2005. What made this documentary different from most others that cover high-profile trials is that it is not about the actual case; it’s intended as a commentary on the legal process itself.

Watching this documentary was a grim reminder that most portrayals of court rooms in popular media fail to understand how memories work. And it turns out, the same is true in the actual legal system.

That’s scary to me. More specifically, an uneducated jury that doesn’t understand that memories are fallible is terrifying. (And prosecutors, judges, and defense attorneys that ignore the research are bad at their jobs.)

How Memory Works Link to heading

Let’s step back for a minute and review how your brain actually works. When we talk about neurology it’s important to remember that our cognition is not yet completely understood, but a lot has been fairly well-established. I will try to speak only about the generally accepted models, but the exact mechanisms for how some of these work have not been proven.

That being said, here is the basic process by which memory works:

You experience something.
You store this memory in your brain. It’s stored in multiple places.
When you try to remember that something, your brain pulls those pieces together and reconstructs the memory from those pieces. Memory is not like a video where you just ‘play it back’, rather we collect all the associated fragments and feelings that are associated with that memory and reconstruct it on the fly.
After recalling it, you then rewrite the memory back to your brain.

It sounds simple and straightforward, but it causes all sorts of problems.

Why Your Memory Sucks Link to heading

Your memory sucks because of two separate bugs in the formula that are highlighted above. When you remember something you reconstruct it from its pieces and after recalling something you then rewrite that memory back to your brain. Memory doesn’t work the same way as a DVD, it works more like a jigsaw puzzle; you grab a bunch of disparate pieces and fit them together in a way that seems to make sense, then put them back in their box.

This leads to two really big problems with memory.

First problem, you don’t know for certain if your memory is something that actually happened or if you are putting the pieces together incorrectly Link to heading

Numerous studies have shown that it’s possible to create totally false memories in people. In one well-known study, the researchers were able to trick a quarter of their subjects into recalling a fake memory about being lost in a shopping mall as a child. They didn’t even need to work very hard.

Working with the family of their subjects, they presented them with 4 events from their childhood, one of which was the fake memory of being lost. The subjects were asked to write down what they remembered about those events and rate how confident they were with the memory being real. This was repeated a few times to see if they remembered additional details, and to further encourage their memories.

Without going into too much detail, 25% of the subjects recalled several details about getting lost in a shopping mall when they never actually did, and several more thought they remembered getting lost but were unsure. And when asked how confident they were of it being real, some of them were very confident.

It makes you wonder how many of your early childhood memories actually happened, and how many are there just because your parents told you about them. When I was 4 my family went on vacation, and while there I got sick and had to be taken to the hospital. For a toddler this is a fairly traumatic memory so you’d think I’d remember it, and you’d be right. The only thing I recall about that trip is a distinct memory of being driven to the hospital.

The only problem is, the streets I remember driving down are in my hometown, which is obviously wrong.

I’ve heard this story told to me so many times that I recall something that I know is wrong, that I know didn’t happen like I remember, but I still remember it.

Second problem, it’s possible to modify the memory as you recall it and ‘save’ it back again Link to heading

Let me take an example from Making a Murderer. I’m only going to deal with the uncontroversial false conviction of Steven Avery in 1985. The documentary covers this event in the first episode of the series, which you can watch in its entirety on YouTube.

For those that haven’t watched it, I’ll summarize:

In 1985 Penny Beerntsen was raped by a blonde haired man with a beard that bore a slight resemblance to Steven Avery, a man known to the police department at the time, but who had a very strong alibi for the time of the incident. Despite this, Steven Avery was convicted of the crime. Why? Because Penny was convinced that he did it.

Of course it’s not remotely her fault, her memory was effectively altered by the police’s evidence gathering process. Here’s the relevant sequence of events that happened after she began to give her statement:

She describes her attacker roughly as blonde haired and with a beard, along with other descriptors.
Someone at the Sherriff’s office says “That sounds like Steven Avery.”
Penny works with a sketch artist to produce an image of her attacker.
The drawing produced looks exactly like an old picture of Steven Avery that the police department has on file, even though his current hairstyle (and that of the real attacker) was very different. (The filmmakers argue that the police department did this intentionally to finger Avery. For our purposes it doesn’t matter how it happened, just that it did.)
She picks Avery out of a line-up that includes him and other men that all appear dark haired.
She continues to be convinced through the trial that Steven Avery was her attacker.
18 years later, DNA evidence proved it was a different individual responsible.

Before you start thinking that it would be really easy to confuse two men who look vaguely similar, realize that the real attacker was almost a foot taller than Steven Avery, who is 5'2".

As you can likely tell by reading this cherry-picked sequence, the problem is that the police department influenced Penny’s recollection of the event. They failed twice here in ways that reinforced each other. First, the sketch they made for her is clearly of Steven Avery. That helped solidify in her mind what her attacker looked like even though it was not entirely accurate. Whether by coincidence or not the sketch produced looks like Avery and not the person responsible. Second, they placed him in a line-up for her to pick out her attacker from. There was one man in the line-up that matched the picture the sketch artist made, and vaguely fit her description, so she was forever convinced that that was the guy.

Think about it in terms of what we know about how memory works. Each time she was introduced to the image of Steven Avery, she was recalling the memory and trying to fit the face she saw onto her attacker. In the line-up especially, she knows that the police think they have the right person, so she picks out the person that looks close to her attacker. It’s not her fault that she associates the image of Steven Avery with her attacker, the police as much as told her that he did it. But when she re-wrote that memory back to her brain, her modified memory now showed her that Steven Avery was the one doing it.

Her memory alone was enough to convict despite the fact that he had 19 witnesses and several store receipts as proof that he wasn’t there. Unfortunately the prosecutor, judge, and jury did not understand how inaccurate memories can be.

How We Can Use This Link to heading

At first there doesn’t seem like a whole lot of useful takeaways from knowing about this effect. You almost certainly won’t change anything about how you see the world, but it’s very good to be aware of. I’m not saying don’t believe witnesses, just keep in mind that someone can honestly be 100% certain about what they saw but also be 100% wrong. This issue comes up a lot with regards to early childhood abuse cases; it’s very easy to accidentally ‘implant’ a false memory of an early childhood event.

One way I do know how to use this has been explored by Jane Mcgonigal, a video game researcher (sort of? I’m not sure how best to describe her). Basically, research has shown that it’s possible to use Tetris to treat PTSD. I highly encourage you to follow that link and learn more, though the gist of it is this: If you experience or witness a trauma, play a pattern-matching videogame such as Tetris or Candy Crush Saga as soon as possible, ideally within the first twenty-four hours after the event. The research shows that the visually absorbing games can prevent your brain from concentrating on the event, so your brain is prevented from storing the memories as vividly as they normally would. You can still recall the events afterwards, but you are less likely to suffer unwanted flashbacks.

Potentially you could try it after the event as well, by recalling the memory and attempting to modify it, but that is not as effective as disrupting the storage of the memory in the first place. Interestingly, if you’ve seen The Hunger Games movies they provide a reasonable description of doing this to one of the characters, though in the movie they do the opposite and transform someones happy memories into traumatic ones…

Other than being aware of this while dealing with your own and others memories, I don’t really see many everyday takeaways from knowing this even though I’m sure there are some. Let me know in the comments what you come up with.

(Pulling your hair out over the witness treatment in Law and Order doesn’t count.)

Portion Control

Tue, 02 Feb 2016 00:00:00 +0000

I’m not very good with portion control. Not only in terms of my eating, but in terms of everything in my life.

I can’t watch just 1 YouTube video, or just 1 episode of a TV show.
I can’t play a video game for only an hour.
I can’t drink just 1 beer.
I can’t eat just 1 piece of chocolate.

I don’t think I’m alone in this. Binge watching Netflix is normal for a lot of people I know, and it’s even crept into advertising campaigns.

For me, food is the most noticeable area for catching this tendency. I know when I’m eating too much and binging on something I shouldn’t be. But other areas are more insidious.

If I decide to spend my break time watching a YouTube video, is that really a problem? No. Not by itself at least, but for me it’s never just one. If I watch one funny video on my break, 50% of the time that turns into an hour or two of binge watching random related videos.

The same is true in reverse, skipping out on a healthy habit is just the same as succumbing to an unhealthy activity. If you don’t do a habit 100% of the time, that actually makes it more difficult. It all comes down to willpower, if you decide in advance that you’ll always do a healthy habit then you never have to waste time and willpower on the decision.

For example, brushing and flossing your teeth. If you don’t floss once a month, that’s probably not a concern. However if you have that attitude going in, that the goal is not 100%, then you’ll inevitably miss more. Missing one isn’t a concern, but that path leads to missing more, which is a problem.

Going on a Diet Link to heading

The most successful weight loss diets have a high focus on teaching portion control and adding healthy foods rather than restricting food intake. Most importantly, they place the focus on cutting out unhealthy domino foods entirely while replacing them with healthy alternatives. If the diet focuses on just restricting the amount of food you would normally eat without changing anything else, it becomes very difficult or impossible to actually follow it.

If you control your binges then they aren’t always bad, but you need to be in control of them. That’s why planned cheat days in diets can be useful. Even though you may over eat for that 1 day, all the other days you’ve cut out binging entirely. If you aren’t honest with yourself about how much you’re actually eating though, then even allowing a cheat day in your diet or habit is a problem.

The usual advice for dieters is to remove all of these trigger foods from your house so there is no temptation. When you get a craving it’s a lot easier to resist if you have to go all the way out to the grocery store to get it. If you’ve left it in your pantry it’s probably going to get eaten.

The same is true for other triggers. Remove YouTube/Netflix/Facebook/etc from the favorites list on your browser. Unplug your gaming console or TV when you aren’t planning on using them. Lay out your workout clothes in the evening (or even wear them to bed!) so you don’t have to search for them in the morning.

If you’ve got a real problem, you can go even more extreme. Several years ago I went 6 months without Internet or cable in my apartment to avoid wasting time on those useless things, and it was liberating. I watched much less TV, started learning how to cook, worked out consistently, was more socially active, and even started dating my current girlfriend. Interestingly I also remember that time more vividly. I chalk that up to being more present in everyday life, rather than being constantly focused on other things.

Most importantly recognize these triggers in yourself. Do as much as you can to avoid the unhealthy ones at all cost, and encourage those that make you healthier.

If you’re worried you may be wasting a lot of time on your computer, install RescueTime. It tracks your Internet browsing and the programs you use on your computer and displays them for you in pretty graph form. Install it, including the browser plugin, and check back after a week or two to see how you do. You may find that you are spending far more time on something unproductive than you would like.

Cognitive Biases

Tue, 26 Jan 2016 00:00:00 +0000

If you’ve never been exposed to the idea of Cognitive Biases, you are probably under the impression that people are typically rational. Sure people are misinformed or uninformed or may have a different value system, but you assume that they probably make decisions consistent with the facts that they have.

Unfortunately that’s just wrong.

The human brain is the most complex known object in the universe, the pinnacle of billions of years of evolution, but it has some…quirks. Maybe our brains evolved too many cognitive ‘shortcuts’ to save on processing power, or perhaps the way our reasoning works still has some bugs in it, but for whatever reason humans have some issues with purely rational thought.

While our brains are fantastic for out-competing other species (and other humans) when it comes to living on the savanna, they fall prey to what are termed Cognitive Biases. These are tendencies for the brain to think in certain ways that result in irrational behavior. Let’s look at some examples:

The Illusory Truth Effect: Ever notice when a politician repeats false or misleading information over and over again? They’re taking advantage of this effect. When you’re exposed to information multiple times, even false information, you are more likely to believe it to be true.
False Memories: It is entirely possible for you to remember doing something that never happened, or remember something happening in a different way than it actually did. The Innocence Project, which helps overturn old legal convictions by using improved DNA testing, has reported that 73 percent of the wrongful convictions they overturned were based on eyewitness testimony. In addition, the Columbia Human Rights Law Review published an investigation in May 2012 reporting that Texas almost certainly executed an innocent man, Carlos DeLuna, based on eyewitness testimony. Read this and never fully trust an eyewitness again.
Hindsight Bias: This is when we believe that past events were easily predictable at the time. While the chain of events looks easy to see in hindsight, we overestimate how easy it would have been to predict in the past. The 2008 financial crash looks like it should have been obvious to predict, but we have the advantage of knowing what happened, and few people caught it at the time. Falling prey to their Hindsight Bias is why a lot of people think they can speculate on the stock market. The reality is hindsight really isn’t 20/20.
The Zeigarnik Effect: Incomplete tasks are better remembered than complete tasks. If you’re finding yourself in the evenings stuck in a mental loop remembering your work day, chances are you’re trying to keep in mind details of an unfinished task or project. Unload all those ideas at the end of the work day and enjoy your evening.

To be clear, that is nowhere close to an exhaustive list. This handy website lists many of them if you’d like to browse through others yourself.

Why You Should Care Link to heading

There are two big reasons why studying Cognitive Biases and learning how to manage them are so important.

First, it’s great internal introspection. If you are really focused on improving yourself, knowing your own faults is vital. Understanding when and how you will make irrational decisions is the first step in becoming a rational thinker. Increasing your own rationality improves your decision making process, and thus every decision you make.

Second, you can use it for external action. Use these deficiencies in rational thinking to manipulate the world to suit your goals. Take advantage of these faults of logic in others and get your competitors to act irrationally. But please don’t use them to take over the world, that would be bad.

In future articles I’ll cover some of these biases in greater detail and hopefully discuss some strategies for dealing with them in your own life.

Willpower is a Limited Resource

Tue, 19 Jan 2016 00:00:00 +0000

In a landmark 1998 study, 67 people were tested to try to determine if willpower was a limited resource. The scientists were able to show that they could deplete willpower in their test subjects through a very simple mechanism, chocolates and radishes.

The experimenters setup a waiting room with a tray of snacks; half the tray filled with radishes and the other with chocolates. One group of participants was instructed to wait in the room and eat the chocolates, while the other group was made to wait in the same room but only allowed to eat the radishes (a third group was used as a controls and wasn’t presented with either food). After they waited and snacked in this room, each of the participants was tasked with completing an impossible geometry puzzle. The experimenters were measuring how long it took each participant to give up on trying to solve it, and the results confirmed their suspicions.

The chocolate group spent 19 minutes trying to solve the puzzle before quitting (The control group gave up after 20 minutes, statistically the same as the chocolate group). The second group, the one tasked with eating radishes and ignoring the chocolate, worked for only 8 minutes before giving up. The radish group gave up more than twice as fast as the chocolate group. The theory of why this happened comes down to what the experimenters term ‘ego depletion’, that the subjects eating the radishes used up their willpower reserves and thus had less willpower to use in the puzzle test. In the years since, this result has been confirmed again and again in related studies.

Let me step back a moment and define the terms. I used willpower in the title of this article as that is the most recognizable term to describe the effect, however the technical term is ‘ego depletion’. Roy Baumeister, perhaps the leading researcher on the subject and one of the authors of the radishes experiment, defines it this way: “The core idea behind ego depletion is that the self’s acts of volition draw on some limited resource, akin to strength or energy and that, therefore, one act of volition will have a detrimental impact on subsequent volition.” In short, willpower is finite.

The studies show that this same quantity is linked to everything you would normally think of as self-control. Namely:

Focus and Concentration
Decision making
Suppressing emotions
Pushing yourself during a workout
Etc.

It’s a measurable physical effect as well. In one experiment, subjects that underwent willpower depletion were shown to have lower glucose levels than subjects who did not. And similarly, feeding ego depleted subjects a sugar-sweetened drink seemed to restore some of their willpower (compared to giving them a drink with artificial sweetener). Glucose, a simple sugar used by your body for fuel, is the primary fuel source used by the brain.

Why You Should Care Link to heading

Sure it’s an interesting experimental result, but what’s really great about the theories of ego depletion are their applicability for personal productivity.

In his book, Daily Rituals, Mason Currey describes the daily rituals of highly creative people. Overwhelmingly, he reports that most of them maintained a set of routines and rituals each day, keeping every day relatively similar. As a recent example, Steve Jobs famously wore the same clothes every day, since while he couldn’t control his daily schedule he could control what he wore each day.

The key point here is not necessarily what any of the rituals actually are, but the fact that they exist at all. What matters is not that Steve Jobs wore the same thing every day, or that Charles Darwin went for a walk every day at noon, but that they did not have to waste their willpower on deciding what to do or wear. Instead, creatives with a ritual are free to use all of their available willpower on the pursuits that they care about.

The studies also show that willpower can be restored via food, sleep, and time. So for many people the morning may be the best time to do your most focus intensive work; that’s when your willpower stores are at their highest.

Apply the Science Link to heading

There are a lot of useful nuggets we can draw from this concept. Most important is to simply stay aware of this fact while planning your schedule. Try scheduling your intense work early in the day. Avoid decision making wherever possible on the least useful parts of your day.

Perhaps most importantly, instead of looking at tomorrow’s empty schedule by saying ‘I’ll figure out what to do in the morning’, rephrase that to be ‘I’m going to use up my limited focus tomorrow morning by checking email and deciding what to work on.’ If you’re still comfortable with that, by all means go ahead.

Further Reading: Roy Baumeister co-wrote an excellent book that explores this in depth. Willpower: The Greatest Human Strength

Resolutions

Tue, 12 Jan 2016 00:00:00 +0000

There’s something about this time of year that inspires everyone to reflect on their accomplishments and look towards the future. There’s nothing inherently special about January 1st, it marks nothing of note in the natural world; the only thing significant is that the last digit of the date changes.

Still, it’s a time for many to make their New Years Resolutions. Almost everyone makes them it seems, though many are too embarrassed to admit them out loud. Everyone is dissatisfied with something about their life, and the constant Buzzfeed-style articles about Resolutions ensure that they are top of mind for most.

The problem is most people suck at making real, lasting changes in their life.

Let’s take an example: Jane

Jane is 29, and she’s unhappy with how she looks. She’s been working a desk job for several years and her body is starting to show it. She’s overweight and dreams of one day having her bikini-ready body back. So she decides to make a resolution for New Years; she’s going to get in shape. Jane buys a year long gym membership and promises herself that she’ll go 3 days a week for the entire year.

For the first couple weeks, things go well. Jane dutifully drags herself into the gym 3 days a week, fighting the massive January gym crowds to spend the requisite 30 minutes working out on the elliptical machine. But one week, at the end of January, she has to work overtime and misses a few days.

Over the course of the next couple days, she doesn’t go either. She’s too tired from working, or deserves some time off exercising as a reward, she tells herself. A few days off turns into a week, then two weeks, and on and on. Jane never gets back on schedule.

She tries again when her 30th birthday rolls around in August, since she still has that gym membership, and lasts a full month before quitting again.

At the end of the year, Jane feels bad about her body and decides that the next year she’ll do better. So she buys a gym membership, resolves to go 3 days a week, and starts fighting the January gym crowds to work out on the elliptical and…

Well that probably won’t work, but you already knew that.

Unfortunately this is how people seem to think they should go about pursuing goals, and it’s why we’re so bad at completing them. It doesn’t mean that you lack willpower or fortitude or resolve or whatever else, it just means that you might be going about it the wrong way. I’m not saying that what Jane did won’t work for some people, but it surely does not work for the vast majority.

Jane made a number of mistakes in trying to lose weight:

She didn’t specify a goal weight. She used ‘get in shape’ as her goal, which isn’t measurable. There isn’t a way to track progress towards ‘getting in shape’ and she can’t really say when she’s done. Without a clear goal in mind it’s difficult to measure how you’re progressing.
She focused on the wrong things. If we assume her goal was to lose some excess weight, working out is not the most important thing for her to be doing. The most important factor for weight loss is diet, so her focus should have been to work on that at first. (As the eloquent folks over at Nerd Fitness have put it, “You can’t outrun your fork”)
She didn’t schedule (or reschedule) her workouts. If you have to decide day by day what you’re going to do, you’ll eventually have an ‘off’ day or three and miss the necessary work.
She lacked an accountability partner. Jane, we can assume, didn’t tell anyone else what her goals were. She didn’t have someone she was accountable to that could help push her back on track when she faltered.
She tries multiple times to change without adjusting any of her plans, hoping that this time she’ll have the willpower to do it. She doesn’t learn from her mistakes and will get more and more frustrated as time goes on.

Here’s the formula that I use to accomplish actionable goals. It’s not particularly detailed, but that’s the point. Everybody is different in what will push them to get what they want, and the idea is to adjust and modify your process for working towards your goals to get there as effective and efficiently as possible.

Pick a measurable, specific goal. You want to be able to say definitively that you accomplished what you set out to do. For weight loss, this means having a goal weight or, even better, a goal body fat percentage. If the deadline is very far away it can be difficult to gauge what you will be able to accomplish, so be willing to adjust if necessary. (As an example, I once accomplished a New Years Resolution before the end of January, so clearly I was underestimating what was possible. Adjust the goal and move on.)
Figure out how to accomplish it. Depending on the goal the path forward may be obvious, but often it isn’t. In the example above, Jane should have started by adjusting her diet first, but she started with working out because she didn’t know the most efficient way to accomplish her goal. Do a little research now and save yourself lots of unnecessary work later.
Break it down into actionable steps or checkpoints, all the way down to what you need to do today or this week. This way you can gauge your progress, plan your work, and know when or if you need to adjust your end goals.
Schedule it. Willpower is a limited resource, so don’t just hope you’ll be in the mood later to follow through, schedule it in advance. If applicable, set aside time in your calendar beforehand to work on it.
Get an accountability partner. Tell at least one other person what you’re doing, and make sure they will hold you to it. If you want to really stay on track, get them to agree to punish you in some way if you don’t stick to it (Studies show that people respond better to negative rather than positive reinforcement). Perhaps give them $50 to hold and if you don’t stay on track, they’ll donate it to a cause you hate. Close friends or family are best, and strangers on the internet are a last resort. I will readily admit that this step is the hardest for me personally, and I struggled with doing this for a long time, but being accountable to another real person is a big motivator to keep going.
Regularly review and update. Pick a day once a week or once a month, to review how you’re doing with the goal. Check in with your accountability partner, adjust the goal if necessary, plan the next week or month, etc. I have a set weekly review time each week for all of my goals and plans.

Let me know how this works out for you in the comments, or what else you’ve found that works for you personally, I’m always interested in hearing about it.