I wrote last month that what you want to do is one of the most useful motivations in life. I want to follow that up by saying that the only thing more important than wanting to do something is to actually do something.

The most valuable trait you can develop for yourself is to be consistent. It is absolutely something you can develop. And moreover it's kind of hard to believe that for anyone it is innate.

I meet so many people who say they want to do things. And I ask them what they're doing to get there and they get flustered. This is completely understandable.

I meet so many students who feel overwhelmed by what everyone else is doing. This is also understandable.

But it doesn't matter what anyone else is doing. It doesn't matter where anyone else is at. It matters where you are at. Compete with yourself before you compete with anyone else. What matters is that you get into a habit of consistently working on little goals.

If you pick something that is too complex, break it down. Keep on breaking problems or ideas down until you find a problem or idea you can solve.

Then keep on finding new problems to solve. Move on in complexity over time as you can and want to.

Don't worry about getting things perfect. Who can discredit you for doing your best? What shame is there when you're being earnest? The only thing that makes sense to feel bad about is not trying to do what you genuinely wanted to do.

And this doesn't have to be about projects or ideas outside of work. There may be things you want to do at work like improving documentation or writing better tests or adding new checks to code or blogging or interviewing customers or working with another team.

Like I said in Obsession, don't worry about what you do daily. That is too frequent to think about. Instead think about what you're doing once a month.

Make time once a month to publish a post or complete a small project. Whatever you want to do, I am confident you can find some small version of it that you could commit to doing once a month. Be consistent!

If a month is too often, pick a longer freqency. Find whatever cadence and whatever size of project that allows you to be consistent.

When you're consistent over the course of months I think you'll be astounded at what you accomplish in a year.

Shorter post tonight, may add to this later on.

Be someone who does things. And do these (little) things consistently.https://t.co/oVb6Sz8eEK pic.twitter.com/kNrZQ4pvTN

— Phil Eaton (@eatonphil) September 24, 2024

Why I Prefer Exceptions to Error Values

Good error handling is key to robust programs, but often dreaded by programmers because there is always one more edge case. Traditional object-oriented programming languages use special exception classes that can be thrown to break the regular control flow for immediate error reporting. Let’s take a quick look at an example that explores error-safe integer division:

int safeDiv(int a, int b) {
 if (b == 0)
 throw Div0(); // Exceptions are passed out-of-line
 return a / b; // Totally safe now, right?
}

Newer languages tend to favor functional-style error reporting and encode errors in their return type: For example, Go encodes the error in the return type with an (res, err) tuple, and Rust returns Result<T, E>, a sum type of result and error. Even older languages such as C++ now include error values in their standard library with std::expected: