Looking back at a pivotal year in my open source career.

Just for fun, what if we represented binary values purely within TypeScript's logical type system?

Breaking down the income streams and totals from my third year as a full-time independent open source maintainer.

Recapping the fantastic in-person conferences I attended in 2023.

Looking back at the accomplishments and goals from my third year as a full-time independent open source maintainer.

Looking back at my second year as a full-time independent open source maintainer.

How to use the energy of new employees to keep documentation up-to-date and useful.

Using the common markdown linter and disabling any rules that would intersect with dedicated formatters such as Prettier.

How I recommend getting your formatter, linter, and type checker to play together nicely.

A thorough guide through contributing to create-typescript-app or any repository scaffolded using it.

How I recommend getting your formatter, linter, and type checker to play together nicely.

How we migrated the massive DefinitelyTyped repository from using a linter for formatting to the dprint formatter.

A mantra for constantly learning to keep myself writing at my best.

Removing type-land entries from import completions that can't be used in value-only-land.

FAQs for contributing to my create-typescript-app project or any repository scaffolded using it.

Medium can eat it. I'm going open source with Gatsby!

Manipulating the details of TypeScript's emitted code to wrestle jQuery 2's older asynchronous constructs to work with modern `async`/`await`.

I'm quitting my job to become a full time open source maintainer

From attending a few dozen conferences and co-organizing one of my own, this is how I make the most of in-person event.

Common questions and answers for my How I Apply To Conferences article.

From a hundred conference applications and thirty speaking roles, this is my process for submitting talks.

Using lazily instantiated, dynamic classes instead of hand-written functions to reduce unnecessary work during loads.

Using the popular NProgress library to visualize load progress on sites built on the AMD RequireJS loader

Native speed for parsing and type checking is wonderful. I also want the huge benefits of writing lint rules in an ecosystem's primary language. Here's how I think we can have both.

IE users are users too!

Speeding up and simplifying the transpiler configuration for a Jest project with Speedy Web Compiler (SWC).

Or: How to suddenly anger everybody, everywhere!

How I'm going to make my 2025 impactful.

How I'm going to make my 2024 beautiful.

How I'm going to make 2023 awesome.

Applying learnings about how humans perceive forces of nature to how we understand code and organizations.

In trying to make ourselves relatable, we reinforce the negative perception of intelligence gaps.

Security is important. Overusing report mechanisms for non-actionable noise is counterproductive.

Maintenance and development costs run both ways. Open source contributors and maintainers alike have to balance their finite energy and time resources within many constraints.

Explaining why the speed gains from Rust linters aren't comparable to the full feature set of typescript-eslint.

What it's like to quit your job and try to work on open source tooling full time.

This is my standard explainer for pull request reviews where changed lines aren't covered by unit tests.

While AI systems such as OpenAI and ChatGPT can be helpful in certain situations, there are also significant risks associated with their use.

Improving a page's performance by over-eager loading most of its embedded content.

Automating changes to module imports to overcome the build system not correctly tree shaking barrel exports.

Finding and removing giant unused assets hidden in marketing page to speed up that page's performance.

Using Knip to automatically detect unused files and dependencies in the Centered repository.

This is a general explainer for pull request reviews where I think unrelated changes should be split into a separate PR.

Finding and eliminating thousands of calls to recreate a giant regular expression in a popular open source emoji plugin.

How to create an effective rickroll site with the Vimeo Player SDK despite modern web browser autoplay restrictions.

Explaining why deep work can be so difficult in open source.

How misbalanced or poorly positioned teams restrict their developers in both the short and long term.

Why separating responsibilities between your formatter and linter isn't always clear-cut.

Maintaining TSLint was a wonderful mixed bag of shenanigans. Let's talk about it.

Now that TSLint is being deprecated, let's look at how tslint-to-eslint-config converts your TSLint configuration to ESLint.

Now that TSLint is being deprecated, let's look at the history of JavaScript and TypeScript linting.

This is a general explainer for pull request reviews where a try...catch statement is used more than I think it needs to be.

Corrects the missing function codefix to add type parameters when the function needs to be generic.

Fixing a slight bug in how TypeScript resolves type elements of tuple types indexed by type parameters.

Just for fun, what if we crafted a board game purely within TypeScript's logical type system?

Allowing derived classes with properties to include code before `super()` call that doesn't touch `this`. A grand pull request three years in the making -- with cake!

More technical descriptions around allowing derived classes with properties to include code before `super()` call that doesn't touch `this`.

A quick syntax parsing improvement for incorrectly formatted enums.

Glorious hardcoding of a better error message if someone forgets to include the 'dom' lib option.

How I made TypeScript's parsing of name characters after numbers conform to the ECMAScript specification just a bit more strictly.

Improving the first error message emitted for invalid variable identifiers.

How I contributed a change to TypeScript that allowed trailing commas in type parameter/argument lists.

How I helped add an 'errors summary' to TypeScript's command-line --pretty --watch mode.

Adding a new comment directive to the TypeScript compiler.

Explaining why using useEffect to initialize values is dangerous.

Typed linting is powerful but requires a full type checker to function well. Today, that means TypeScript. This is why we haven't found a suitable replacement yet.

Twitter has been a core part of my web development career for over a decade. But Twitter's been replaced by the vastly inferior X. Here's why I'm finally ready to commit to Bluesky.

Explaining two popular Prettier integrations for ESLint, and why I avoid both of them.

This how I would architect a modern linter from scratch: focusing on built-in TypeScript support, a straightforward rule development experience, and deduplicating tooling.

This is how I would tailor the developer experience for a modern linter from scratch: focusing on end-to-end type safety, self-apparent configs, and native workspaces.

This is how I would steer a new ecosystem around a modern linter from scratch: emphasizing shared terminology, a plugin registry, and one-way compatibility layers.

Summarizing the last three posts of ideas for a new linter, along with next steps for its Flint prototype.