
## Thanks, I hate it

In the first days of building [Craftwork](https://craftwork.com), I made the decision to use Tailwind CSS for our projects. This choice was driven by tailwind's adaptability, and its popularity among developers.

Here's the thing though: Tailwind and I don't really get along. I've spent years learning to create design systems with traditional CSS. More recently I found myself building products using full-blown UI libraries like Material UI and Chakra, because they make it _super_ fast to build a rich, functional, and accessible UI.

By contrast, Tailwind is somewhere in the middle of these two. On some level it bypasses the nuanced understanding and control that come with writing raw CSS. It's also not _fully_ functional out of the box like Material UI or Chakra - and yet... for so many reasons, it's _really_ good.

For us, Tailwind provides some huge benefits:

- **Speed**: Tailwind's utility-first approach allows us to quickly implement designs without having to write custom CSS. This is especially useful when we're iterating on designs and need to make changes quickly.
- **Universality**: At Craftwork, our stack includes Ruby on Rails, Next.js, and React-Native. Tailwind's flexibility allows us to use the same styling system across all these platforms, which is a huge win for us.
- **Talent**: Craftwork isn't just me, and it never will be. Tailwind's popularity across the industry has made it almost trivial to find developers who are familiar with it. This is a huge win for us as we grow our team.
- **UI Libraries**: Due to its popularity, there _are_ many UI libraries built around Tailwind, including: [TailwindUI](https://tailwindui.com), [ShadCN UI](https://ui.shadcn.com/), and [Aceternity UI](https://ui.aceternity.com/components). Costs to license each of these libraries vary (some are even free!), and they're essentially copy-pasteable components that you can use to build your products. Very cool.

## What this means for us in practice

Tailwind's adaptability is really what shines; from day one, it has enabled us to onboard new teammates, and build interfaces more rapidly. Its consistent utility across our entire stack means that regardless of the project, new team members can quickly read, understand, and contribute to our codebase. The decision to use Tailwind, therefore, wasn't just about adhering to current trends or sidestepping the complexities of CSS; it was a strategic move to ensure our team can hit the ground running, maintaining agility and coherence across our diverse projects.

This underscores a more important principle in tech selection: aligning tool choices with team dynamics and project requirements is a skill. It's a delicate balancing act -- weighing the benefits of technological efficiency and team scalability against the richness of personal expertise and the depth of traditional craftsmanship. It's a reminder that our growth as developers is not just about keeping up with the latest tools but also about valuing and honing our foundational skills.

Put another way, for everything we build, we have to balance velocity and quality. Tailwind is a tool that gives us wins in both columns.

## What I'd like to see change

All that being said, I do still have a wishlist for Tailwind:

1. **Better tooling**: Tailwind's approach to utility-first CSS is great for performance, but it also means we have to configure Tailwind to compile per-project, so that it only includes the styles we use. When this (infrequently) breaks, it can be difficult to detect, and debugging it isn't always straightforward.
2. **Better IDE support**: Tailwind provides a consistent language for styling our apps - there are plugins for VS Code's Intellisense that make it easier to write Tailwind classes, but it doesn't _always_ work. This can make it difficult to remember the exact class names for certain styles, and can slow down our development process.
3. **Prettier Prettier rules**: Adding tailwind classes to html means that we often have long lists of class names added to our html. This causes individual lines of code to be very long - despite what many engineers will tell you, this is [demonstrably worse for UX](https://www.nngroup.com/articles/f-shaped-pattern-reading-web-content/) than having class names listed on separate lines. There's [lots of discussion about building a prettier rule](https://github.com/tailwindlabs/tailwindcss/discussions?discussions_q=multiple+lines) for this, but as far as I've seen, there's not a great solution yet.

<Image
  publicId="newsletters/i-hate-tailwind-css-heres-why-i-use-it/horizontal-scan"
  alt="Screenshot of tailwind css code resulting in lots of long lines of code, causing horizontal scanning issues"
  caption="Like it or not, a horizontal list of classes is more taxing than a vertical list would be."
/>

So in the end, do I hate Tailwind? No, of course not. I've come to appreciate it for what it is: a pragmatic choice that has helped us build better products, faster. And that's something I can get behind.

**I'd love to hear from you**. What are your thoughts on Tailwind? Do you have any tips for using it more effectively? Is there a UI Library you love that I missed? Maybe you have a wishlist of your own? Let me know by replying to this email.

---

## What I'm thinking about this week: Watching experts work

### 🎶 A musical savant showcasing mastry

There's something extremely satisfying about watching someone who's really good at their job do their thing. I've been sharing this video of musical composer [Jacob Collier using Logic masterfully](https://www.youtube.com/watch?v=tVHyuhsAles) to compose a song in real time. There's such a beautiful confluence of skill, creativity, and deep understanding in this video.

The best creative tools make superusers shine, and I think that's something we should all strive for in our work.

### 🔌 Plug kinda nerdy, but he chill

I was pretty deep in the YouTube rabbit hole when I came across [@AllThingsOnePlace](https://www.youtube.com/watch?v=-JkUcrlDtZ0). This is an electrical engineer whose videos are all about analyzing and reviewing power supplies and other electrical components. I promise it is _way_ more interesting than it sounds. I had no idea that you could measure the _quality_ of power coming from a USB charger!

---

## More from me

### 🎙️ [Every business is an API business](https://apisyouwonthate.com/podcast/allan-knabe-apiable-api-portal/)

In my recent podcast interview with Allan Knabe from Apiable for APIs You Won't Hate, we dicussed how Apiable is building an API Portal service that helps API teams to create, secure, market, and monetize API products. Catch it on the [APIs You Won't Hate feed here](https://apisyouwonthate.com/podcast/allan-knabe-apiable-api-portal/)), or wherever you listen to your podcasts.

### 🎥 [I've been more active on YouTube](https://youtube.com/@mikebifulco?sub_confirmation=1)

Over the past month or so, I've gotten back into live coding on YouTube on the weekends. I've also got plans to start publishing more dev tutorials and startup content. If you're interested in that kind of thing, [subscribe to my channel](https://youtube.com/@mikebifulco?sub_confirmation=1) to stay up to date.

---

Hey, one more thing: make sure you [register to vote](https://vote.org). It's important. Like, deeply, existentially important.


I hate Tailwind CSS. Here's why I use it.

What I'm thinking about this week: Watching experts work

🎙️ [Every business is an API business](https://apisyouwonthate.com/podcast/allan-knabe-apiable-api-portal/)

🎥 [I've been more active on YouTube](https://youtube.com/@mikebifulco?sub_confirmation=1)


## Raise your hand if you've done this before:

You're working on an exciting new feature, new article, or doing _anything_ creative. You're in the zone, and you're feeling good. You're making progress, and you're excited about the outcome.

Then, a thought occurs. Is your approach going to be scalable? Will it be maintainable? Do other people have a better way of doing it? So, you go into research mode, and start scribbling down notes for your new plan of attack.

Hours later, you're still researching. You've read a dozen articles, watched a few videos, and you're more confused than ever. You've found a dozen different ways to do it, and you're not sure which one is the best.

You're spiraling. Next thing you know, you've wasted days thinking about how to do it, and you haven't made any progress.

## Choice: Flip it and reverse it

I've been on vacation for the past week, traveling throughout Vietnam with my wife. She had a a two-year stint teaching at an international school in Hanoi, so I've spent lots of time here over the years. It's one of my favorite places in the world. People here are kind and charming, and the food and coffee are incredible.

One of the things that is the most striking about visiting vietnam is that driving is very different here than in the states. Most people ride 150cc motor bikes, and traffic can feel like a bit of a free-for-all at first. There are clear lane markings on most road, but cars and bikes drift between them without warning. Traffic lights here actually count down the seconds until they change, and it's not uncommon to see people leave a stoplight a second or two before it turns green.

There are also very few traffic accidents, from what I've seen. People are very aware of their surroundings, and they're constantly adjusting their speed and direction to avoid collisions.

It can be a bit jarring at first, but it's also a lot of fun. It's a bit like a dance. Everyone is moving in a different direction, but somehow, it all works out.

I've been thinking a lot about this over the past week, and I think there's a lesson here for us as makers. The rules (written & unwritten) that have developed for driving here are the result of a different set of constraints than the ones we have in the states. The roads are narrower, and there are more people. The cars are smaller, and the bikes are faster.

The rules that work here wouldn't work in the states, and vice versa -- but they solve the same problem. More importantly, they solve the problem _well,_ and one isn't better than the other.

<Image
  publicId="/newsletters/no-right-way-to-do-it/cafe"
  alt="My laptop on a table next to an espresso and a glass of water, at a cafe in Hanoi"
  caption="Was I up at 6:30am to write a newsletter while on vacation? Maybe. But it shipped!"
/>
## There's no right way to do it

This had me thinking about the way we build products. I've talked to many founders and indiehackers who spend the early days of their product journey researching the "right" way to do things. They spend more time talking about _the thing_ than building it. They talk about the problem to no end, and don't make any progress on the solution.

Friends, here's the thing: **just ship something**. Ship it. Ship it. Ship it.

Deploy your code, put it in front of real people, and open your mind and your heart to feedback and criticism. You'll learn more in a week of shipping than you will in a month of research.

There's no right way to do it. There _are_ many ways to do it, and if you ship more often, you'll find a path that works for your project. You'll be able to change more rapidly, and you'll be able to adapt to the needs of your customers.

You'll become a better product builder by shipping products, not by reading about how other people build products.

---

## Send me your project

Here's your call to action for the week: I want to know what you're working on, and I'd love to share your work here in Tiny Improvements. Send me what you're working on, and I'll share it with the community. I'll also give you a shoutout on Threads and LinkedIn.

Hit reply on this email, and send me a link to your project. I can't wait to see what you're working on!

---

## Recommendations from my playlist

- 🎙️ Colin & CJ over at [Build & Learn](https://buildandlearn.dev/) have been podcasting about career growth and building things as software engineers. CJ is a teammate of mine at Craftwork, and Colin works in DevRel at Discord - they're two devs who really know their stuff.

- 📖 I just finished listening to [Oversubscribed](https://www.amazon.com/Oversubscribed-How-People-Lined-Business/dp/B085P1N7LR/ref=sr_1_1?keywords=oversubscribed&qid=1698715330&sr=8-1&_encoding=UTF8&=irreverentm04-20&=ur2&=37e3d32d3a23dee0fda9150b61b2e135&=1789&=9325) on Audible. The book's tagline is "How to Get People Lined Up to Do Business with You" - and it gets right to the point. It's a great read for anyone who is building a product or a business, and it's full of proper advice from real-world experience.

## What I'm working on

- 🎙️ In my latest interview for Software Engineering Daily, I talk to [Tsavo Knott, the CEO of Pieces for Developers](https://softwareengineeringdaily.com/2023/10/25/building-pieces-app-and-the-future-of-developer-productivity-with-tsavo-knott/) about their product, an automated second brain for devs and engineering teams using some insanely cool multi-modal LLMs. If you've ever had that feeling that you read about something _somewhere_ but now you can't find it, Pieces is looking out for you.
- 🧶 I have been posting quite a bit on [Threads (@irreverentmike)](https://www.threads.net/@irreverentmike) lately. These days, the tech community on Threads is feeling a whole lot like the best days of twitter (RIP), and it is really refreshing. If you're active on Threads, hit me with a follow - I'd love to follow you back!


There's no right way to do it

Raise your hand if you've done this before:


A few years back, I started a new job at Google, managing a team of Developer Advocates for Google Assistant. I was excited to be working with a high performing team and with an innovative product ecosystem, but I was also nervous about the transition. I had previously been working on a small but mighty team of just a few people. This was the first time I would be managing, and I was worried that I wouldn't be able to keep up with the demands of my new role.

I needed to find a way to increase my productivity and efficiency, and to prioritize tasks, so I could be able to quickly access the information I needed to do my job. I would be managing many interpersonal relationships, so keeping track of the details of everyhing and everyone I met was critical. I needed to be able to quickly and easily recall informatiom about ongoing projects, as well as the latest news from the world of voice tech.

If you work in tech already, this is probably a familiar story. To stay on the ball and manage stress, I needed to amplify my productivity and stay organized. I needed to build a second brain.

<SponsoredSection
  sponsorName="Skillshare"
  CTAtext="Learn More"
  href="https://vpdae.com/redirect/sx1yvno03hdz0yq7iv053b6d3s4"
>
  <div className="grid md:grid-cols-2 gap-4">
    <Image
      publicId="newsletters/unlock-productivity-with-networked-note-taking/skillshare"
      alt="Skillshare"
    />
    <div>

      ### Explore Thousands of Creative Classes

      Get started with one month free.

    </div>

  </div>
  <img src="https://www.vpdae.com/open/5586.gif?opens=1" width="1" height="1" />
</SponsoredSection>

As software developers and entrepreneurs, we often find ourselves juggling multiple projects, deadlines, and priorities simultaneously. With so much going on, it's essential to have effective tools and strategies in place to help us stay organized and focused.

This is going to sound completely wild, but the most profound change I made in the way I learn, work, and operate day to day was simple:

## I started taking notes.

Specifically, I adopted a technique called networked note taking (also called _zettelkasten,_ _second-brain,_ and more generally _Personal Knowledge Management_, or _PKM_). Essentially, networked note taking involves creating a web of interconnected notes that link together various ideas, thoughts, and concepts. By using note-taking tools like Obsidian, Roam Research, Notion, or Logseq, you can create a digital archive of your notes that allows you to quickly access and retrieve information when you need it.

So why is networked note taking so useful? For one thing, writing things down helps free up mental energy. Writing things down offloads some of the burden of _just remembering things_ from your brain. Instead of trying to remember everything in your head, you can capture your ideas in real-time and let the tools do the heavy lifting of organization and retrieval.

This gives you more mental space to focus on the things that really matter. You can spend less time worrying about remembering things and more time prioritizing and focusing on what's important now.

<Image
  publicId="newsletters/unlock-productivity-with-networked-note-taking/networked-notes"
  alt="A redacted screenshot of some of my notes from interviewing at Google, showing dozens of interrelated names, topics, and ideas"
  caption="I took notes furiously during my interview process at Google. This helped me remember all of the people I met, and the topics we discussed, and draw connections between common themes and ideas in the many discussions I had."
/>

### Remember without forgetting

Another benefit of networked note taking is that it ensures that your notes remain accessible without any loss of fidelity in the future. As much as we'd like to think that our memories are perfect, they're not. We all forget things from time to time, and we all make mistakes. Even with traditional note taking methods like pen and paper, notes can become lost, damaged, or misplaced over time. But with networked note taking, you can rest assured that your notes will always be available and easily searchable.

### Drawing connections between ideas

One of the biggest benefits of networked note-taking is that all of your notes become more valuable the more you write, as the network of connections between notes grows. As you write and link more notes together, you'll start to see patterns and connections that you might not have otherwise noticed. This can help you generate new ideas, solve problems, and make better decisions.

Networked note taking is also a great way to build a personal knowledge base. As you write more notes, you'll start to see patterns and connections between them. This can help you generate new ideas, solve problems, and make better decisions. If you're building a product, this is the kind of thing that can be a complete game-changer.

---

<Image
  publicId="newsletters/unlock-productivity-with-networked-note-taking/obsidian-screenshot"
  alt="screenshot of Obsidian desktop and mobile apps"
  caption="These tools allow you to stay organized, and help you see connections between your ideas. Screenshot from Obsidian's website, Obsidian.md"
/>

## The best tools for networked note taking

If you want to get started with networked note-taking, it's a good idea to find a tool that works for you, and stick with it. I recommend giving each of these a look and seeing which one feels right for you.

- [Obsidian](https://obsidian.md/) is a great place to start. It's powerful, has a great UI, and will help you get that allows you to create a network of interconnected notes. It's free for personal use, and for $8/month there's a premium version that includes additional features like cloud sync and version history. Obsidian has a great community behind it, and a lot of great resources to help you get started.

- [Logseq](https://logseq.com/) is a free, open-source networked note-taking tool that focuses on privacy and security. It has a handful of really cool features for learning, like PDF generation, a built-in flashcard tool, and whiteboarding features. It's also free, and because it is open-source, you can contribute to the project and help make it better.

- [Roam Research](https://roamresearch.com/) is a minimalist note-taking tool, and my personal choice for networked note-taking. A few years back, Roam was the tool that started a bit of a craze about networked-note-taking online. I like it because it is simple, and fast, and has great keyboard shortcuts for getting things done. Admittedly, it doesn't feel like it's received a ton of user-facing updates in recent months, which is a little discouraging. It's also fairly expensive at $15/mo or $165/yr -- and for full transparency, I purchased an early membership for a one-time fee.

- [Notion](https://notion.com) is... _not exactly_ a networked note-taking tool. I'm mentioning it here because I know _many_ people who use Notion effectively to stay organized. I think it's a great product, and we've been using it at my new company to stay organized. Because it doesn't support back-linking, it's not really a networked note-taking tool, and it's not really a knowledge base tool. It's a bit of a jack-of-all-trades, and I think it's best used for things like project management, task management, and personal knowledge management. Come at me, Notion gang 😘

---

## How to get started with networked note taking

If you're new to networked note-taking, it can be really helpful to check out some tutorials and guides to get started. Here are a few of my favorites:

- [Zettelkasten.de](https://zettelkasten.de/posts/overview/) offers a great overview of the zettelkasten method, and how to get started with it.
- YouTuber [Tiago Forte](https://www.youtube.com/@TiagoForte/search?query=notes) has a _ton_ of great videos comparing note-taking methodologies, and breaking down how he uses notes to stay organized in his job and personal life. He also published a book called [Building a Second Brain](https://amzn.to/3KvvCvn) which goes into deep detail on networked note-taking.
- It may be helpful just to watch someone take networked notes, too. Connor Sullivan, founder of Roam research has a 3.5 hour long [video of him taking notes in Roam](https://www.youtube.com/watch?v=ScRrcL__SSI) -- dive in for as long as you like.

## More from my second brain

In the weeks to come, I'll be sharing more of my notes and thoughts on networked note-taking, and how it's helped me stay organized and focused. I'm planning to share a bit about some of my favorite note-taking workflows, including:

- Second brain as a personal CRM
- Daily journaling for mental clarity
- Taking personal meeting notes to stay organized
- Notes for writing: how I build my blog posts over time

So -- stay tuned! If you're interested in PKM/second-brain/networked note-taking, I'd love to hear from you. What are you using? What are you working on? What are your favorite tools and workflows? Reply to this email and let me know what you use. I read every single reply, and I'd love to hear from you.


The productivity tool I use every day to multiply my output

How to get started with networked note taking


This week, I'm thinking about the lifecycle of moonshot companies. In particular, ones we may have forgotten about as they lost popularity.

A moonshot company is one that aims to solve a big problem, but is unlikely to be profitable in the short term. They're often started by a small team, and are often funded by venture capital. The idea is that they'll grow quickly, and eventually become a big company that solves a big problem.

The term comes from the old adage, _Shoot for the moon. Even if you miss, you'll land among the stars._

_Most_ moonshot companies don't make it to the moon or the stars. Instead, they become a stepping stone for new use cases, competition, and other product ideas. Every once in a while, though, an interesting thing happens -- an app that was once outrageously popular seems to fade into obscurity. I'm not sure why this happens, but it's worth thinking about.

## A blast from the past

You may remember [**FourSquare**](https://foursquare.com/), the popular app which let you check-in to a location and review it. If you checked-in frequently enough, you could become "mayor" of the spot.

It was a super cool idea that ended up being a direct competitor to Yelp, Google Maps, Trip Advisor and other services like them... and I thought it was _gone gone_ until last week, when a colleague mentioned that he was still using it. Get this: FourSquare has a loyal following! Superusers leave reviews on the app which tend to be more thorough and trustworthy than Yelp.

So, surprisingly enough, I reinstalled the app! It ended up being a great way to find good coffee shops while visiting my team in New York last week.

## Remember these apps?

- **Vine** was a social network that let users share 6 second video clips that would repeat when viewed. It was acquired by twitter in 2012 for $30M, and was eventually shut down because Twitter had other plans for video on their platform... and now the world uses TikTok, whose parent company, ByteDance, is worth an estimated $300B.

- **HQ Trivia** was a live trivia game show app that was wildly popular in 2018. It was acquired by the gaming company, Intermedia Labs, for $100M, and then shut down in 2020. Strangely, it appears to have been rebooted, asit is once again available in the app store.

- **Path** was a photo sharing social network app, which was popular in the early 2010s. It was founded by Shawn Fanning (of Napster fame) and was acquired by a South Korean company called Kakao in 2015. It was shut down in 2018, and the app is no longer available in the app store.

- **Yo** is definitely my favorite among this group. It was an app that let you send a message to your contacts -- and the only message was "Yo", accompanied by a sound effect. It was cofounded by [Or Arbel](https://twitter.com/orarbel), and the company raised $1.5M in funding. It was all over tech news for quite a while, but somehow never found a path to profitability. Even still, I sent my fair share of `Yo` messages to friends. I'm still not sure why, but this app has a special place in my heart.

## Recommendations: No-code for everyone

🤓 Last week, an article that I worked on for a while finally went live. [Devs: It's okay to use no-code tools](https://dev.to/stripe/devs-its-okay-to-use-no-code-tools-1gld) is a treatise I wrote to devs, imploring them to _try_ no-code tools. It's so much easier to automate work today than it was even just a few years ago. Even if you don't consider yourself technical, you can make something impressive with no-code tools.

🧪 Along those lines, [Mike Cardona](https://twitter.com/CSMikeCardona) has been publishing [Busy to Leveraged](https://letters.busytoleveraged.com/), which is all about how to build an automated a business with no-code tools.

🤖 My friend Aron Korenblit has been writing about automation for _years_ on his site [Automate All the Things](https://www.aatt.io/). Did you know you can use an Airtable as the content source for an entire website? Some real magic there.

📸 [Shottr](https://shottr.cc/) for MacOS is one of the best tools I've found for quickly annotating and sharing screenshots. It's optimized for new M1 Macs, too, so it's is super quick, and best of all - it's free!

## Please, make sure you're registered to vote!

(This is for my American friends - sorry international readers, but you'll have to bear with me for this one).

For crying out loud, please make sure you're registered to vote. Next month the US holds Midterm elections, and keeping the Congress in Democratic control is critical to the future of our country. You can check your voting registration status and register to vote over at [vote.org](https://www.vote.org/register-to-vote/).


Remember these apps?

Please, make sure you're registered to vote!


<Aside type="note">

**Note:** This is an update to my recent post, [How to make VS Code load faster with a little bit of housekeeping](https://mikebifulco.com/posts/make-vs-code-load-faster-by-removing-extensions).
I was pretty happy with the startup speed I gained by removing a few
extensions, but VS Code still took a while to load.

</Aside>

Yesterday I stumbled on something that let me **load VS Code 775% faster** than before on my Mac laptop. Seriously. On a cold boot of VS Code, my load time went from 15 seconds to just about 2 seconds. So, how did I do it? Let's cut to the chase:

## The Solution

**If you are running Visual Studio Code on a Mac with an Apple Silicon processor (also known as an M1, M1 Pro, or M1 Max), you will get a _massive_ performance boost by installing an Apple Silicon optimized build of VS Code.**

This is because previous builds weren't natively compatible with Apple Silicon, and ran Intel code through a virtualization process that apple calls Rosetta.

The fix: **Download the [latest version of VS Code](https://code.visualstudio.com/download) for Mac, install it.** If you were previously running an Intel build, this is _all_ you need to do. That's it!

## What's going on here

In 2019, Apple released their first round of computers that run on their own processors, which they call Apple Silicon. These chips are fundamentally different from the Intel processors that Apple was using on all of their computers until recently. Apple found massive performance benefits from their migration to a new chipset, but running software on the new processor architecture requires app developers to recompile their software for the new chips.

Thankfully, engineers at Apple were smart enough to know that asking every Mac app developer in the world to recompile their apps for Apple Silicon will take a very long time. To hedge against this, they built a recompilation layer into MacOS called _Rosetta,_ which allows Intel apps to run on the new chips. Because there's essentially a thin VM layer running these apps, they are slower and less energy efficient than apps compiled specifically for Apple Silicon.

That's exactly the gain we're finding here by updating VS Code. There wasn't an Apple Silicon build available until [September of 2020](https://github.com/microsoft/vscode/issues/101662), due to VS Code's dependency on Electron to run.

If this quick fix helps you and you're like me, you likely installed Code long before September of 2020. Your install of Code would get regular updates, but you were getting Intel builds of the app. Switching to a more recently downloaded version of the app will automatically install an Apple Silicon build, and just like that, you're sorted! 🧙‍♂️

## Check to see if you're running an Intel version of VS Code

In the process of figuring all of this out, I discovered that you can actually see which apps on your machine are running Intel builds vs Apple Silicon Builds.

To check any given app, follow these steps:

1. Open **Activity Monitor** (hit command + Space, and type in "Activity monitor")
2. Right click on one of the _headings_ at the top of the table of running processes, to see a list of possible columns for the table.
3. Make sure the option called **Kind** is checked
4. You'll now see a column labeled "Kind", which will say "Apple" or "Intel"

<Image
  publicId="posts/make-vs-code-load-faster-mac-apple-silicon/kind-column"
  caption="The 'Kind' column in Activity Monitor tells you which processor architecture every app is built to run against"
  alt="Screenshot of Activity Monitor, with the 'Kind' column added"
/>

If you're running an Intel version of VS Code, you'll see something like this:

<Image
  publicId="posts/make-vs-code-load-faster-mac-apple-silicon/intel-build"
  caption="The 'Kind' column will say Intel - and I bet your load times for VS Code could be much better."
  alt="Screenshot of Activity Monitor, with the Visual Studio Code row highlighted, and the 'Kind' column showing 'Intel'"
/>

If that's the case, I have great news! You're probably going to see a massive speed boost. This is a good time to close VS Code and time how long it takes to start fresh. On my M1 Macbook Air with 16GB of ram, it took about 15s.

Now, go **Download the [latest version of VS Code](https://code.visualstudio.com/download) for Mac** and install it on your computer (Choose to "Replace" the old install if prompted).

When that's done, you should see this the next time you load VS Code:

<Image
  publicId="posts/make-vs-code-load-faster-mac-apple-silicon/apple-build"
  caption="The 'Kind' column will say Apple"
  alt="Screenshot of Activity Monitor, with the Visual Studio Code row highlighted, and the 'Kind' column showing 'Intel'"
/>

How was that load time now? For me, it was down to _about 2 seconds!_ It's not every day you get those kind of gains.

## If you found this helpful, you may want to check out:

- **[How to make VS Code load faster with a little bit of housekeeping](https://mikebifulco.com/posts/make-vs-code-load-faster-by-removing-extensions)**, my previous post on speeding up VS Code
- **[I reclaimed 10GB of disk space from `node_modules`](https://mikebifulco.com/posts/reclaimed-10gb-of-disk-space-from-node-modules)** if you also happen to use Node to write JavaScript apps.
- **[gitignore.io is great](https://mikebifulco.com/posts/gitignore-io-is-great)** for a tip on a super helpful tool for setting up `.gitignore` files on new projects.


Massively speed up VS Code loading time on Apple Silicon Macs in one step

Check to see if you're running an Intel version of VS Code

If you found this helpful, you may want to check out:


<Aside type="info">

**🚨Update: 11-24-2021🚨**

If you're looking to speed up VS Code and you're _also_ using a Mac with an Apple Silicon Chip (an M1, M1 Pro, or M1 Max), you should read this article first: **[Massively speed up VS Code loading time on Apple Silicon Macs in one step](https://mikebifulco.com/posts/make-vs-code-load-faster-mac-apple-silicon).**

The tips in this article are still perfectly valid, but you'll see much, much better gains from the new tip. Come back here after you've done that.

</Aside>

If you're a user of Visual Studio Code, you may find that over time it feels like new IDE windows are slow to load. In my experience, loading an environment from a cold start (firing up VS Code when it isn't running at all), or opening a window for a new project (`File >> New Window`) when Code is already running tend to take about the same amount of time.

This is notably different from opening a new tab within the IDE - again, in my experience, once Code is up and running, new tabs take almost no time to fire up.

## Why is it slow?

In its most basic form VS Code is fairly performant - a fresh install of the IDE opens very quickly. Over time, if you're anything like me, you've probably installed any number of community-built [extensions from the VS Code Marketplace](https://marketplace.visualstudio.com/VSCode)

## The Solution

Well, the good news is that this one is exactly as easy as it sounds - you can gain quite a bit of startup performance by **removing unused and unnecessary extensions from VS Code**, by opening your Extensions pane (`Shift + command + X` on a mac, likely `control + shift + X` on Windows/Linux), and typing `@installed` into the search bar at the top of the list to see which extensions are currently installed. In my case, it looks like this:

<Image
  publicId="posts/make-vs-code-load-faster-by-removing-extensions/vscode-extensions-pane"
  alt="VS Code Extensions pane highlighted in red"
  caption="My installed extensions pane, highlighted in red"
/>

Extensions with particularly long load times will have their "Activation Time" highlighted in this list. It's currently shown in the upper-right corner of the extension list item with a load time in milliseconds listed next to it:

<Image
  publicId="posts/make-vs-code-load-faster-by-removing-extensions/extension-load-time"
  alt="VS Code Extensions pane highlighted in red"
  caption="My installed extensions pane, highlighted in red"
/>

## How to remove extensions with long activation times from Visual Studio Code

1. Scan through your list of installed extensions, and remove any you don't use
2. If there are remaining extensions which have high activation times listed, consider whether there's better options available (and install those!)
3. If there aren't better options available, you'll either need to live with the load time for a given extension, or choose to bid it farewell. Worth noting here: these extensions are (generally) open-source, so you may want to visit the repo for that extension and [search for "activation time"](https://github.com/prettier/prettier-vscode/issues?q=activation+time) to see if anyone else is running into the same problem. If not, you might want to open an issue and let the maintainers of that extension know you're having trouble, or open a PR if you have a solution to offer up.

...and that should do ya! If you're still running into performance issues after this, it could be any number of things. Are you running out of disk space on your computer? Maybe you're running out of available RAM? Are you running other applications that slow your machine down?

Additionally, if you're a JavaScript or Node app developer, you may want to check out my article on [Reclaiming Disk Space from `node_modules`](https://mikebifulco.com/posts/reclaimed-10gb-of-disk-space-from-node-modules).

I hope this helps! Feel free to share it with a friend if you found it useful.

This post was inspired by a tweet I let fly recently after playing with load times in [Visual Studio Code](https://code.visualstudio.com/):

<Tweet
  tweetLink="https://twitter.com/irreverentmike/status/1454054616027574283"
  align="center"
/>

_note: Cover photo for this article is from by <a href="https://unsplash.com/@loic?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Djim Loic</a> on <a href="https://unsplash.com/s/photos/time?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>._


How to make VS Code load faster with a little bit of housekeeping

How to remove extensions with long activation times from Visual Studio Code


I recently finished reading _Working in Public: The Making and Maintenance of Open Source Software_ by [Nadia Eghbal](https://nadiaeghbal.com/), thanks to a book club organized by [Chris Traganos](https://twitter.com/chris_trag) at [Stripe](https://press.stripe.com/). While I can't say this is a book I would have found my way to own my own, I found myself tearing through it far more quickly than I would have guessed. I'd fully recommend giving it a read - you can pick it up on [Amazon](https://smile.amazon.com/Working-Public-Making-Maintenance-Software/dp/0578675862).

Below is a pretty raw copy/paste of my notes on _Working in Public_, which I take in Roam Research as I read. If you'd like to discuss any of this with me, drop me a line on [twitter @irreverentmike](https://twitter.com/irreverentmike).

**Notes on _Working in Public_**

# Part 1

## Chapter 2: The Structure of an Open Source Project

- &#8203;
  <Highlight>
    Developers don't contribute to open source for lack of technical ability,
    but rather due to fear of committing a faux pas
  </Highlight>
  - There's a huge hurdle to get over here, particularly for new contributors. Even
  sending a very small PR or opening an issue has a mental tax associated with it
  that can prevent progress, community from being built
- &#8203;

  <Highlight>
    The process of getting a change approved depends, among other things, on the
    **complexity** of the change (and the complexity of the project), as well as
    one's **reputation** among those with the ability to approve the change.
  </Highlight>

  - Reputation is a tricky currency, particularly when some folks build clout by
    being funny / sarcastic to gain viral notoriety. This doesn't necessarily equate
    to value to the community or trustworthiness, but often can be parlayed into exactly
    that.

- &#8203;

  <Highlight>
    If a project's contributor base is growing rapidly, and there is enough work
    to hand off, maintainers may start to distribute work more widely. In a
    **distributed** state, maintainers actively recruit more contributors to
    pitch in, with the goal of retaining them in the project.
  </Highlight>

  - At some point, the success of a project causes a requirement for a shift in operations
  - from building the thing to **supporting** it, and recruiting community members
    to help get things done on either end of that. Teams' ability to make that pivot
    is critical to success.

- &#8203;

  <Highlight>Healthy open source (re: node.js contribution policy)</Highlight>

  - Design a contribution policy and code of conduct which entices contributors **and** retains them. Based on my experience, this is the magic in getting something over the hump from being fledgling to more broadly successful.

## Chapter 3: Roles, incentives, and relationships

- Open source developers were frequently characterized as "hobby" devlopers
  - Hm! TIL.
- A theory of the commons
  - In the last half of the 1900s, economist Elinor Ostrom came up with an 8-part theory to what makes up a successful "Commons", or resource that is owned, used, and managed by a community. These rules outline the basic tenets of what makes a successful commons, and apply directly to successful OSS in many ways.
  - Making sure members are biased toward **working together** is a key to success. This may mean distributing knowledge and capability so that everyone has value and meaning, and no one person can hold up the process. Obviously encouraging collaboration is a valuable outcome here, too - so empowering folks to use each other as a resource is extremely helpful.
- <Highlight>
    Intrinsic motivation makes it easier for people to self-organize to achieve
    the same outcome.
  </Highlight>

- The newcomer effect
  - <Highlight>
      "Because newcomers have not yet developed commitment to the group and have
      not yet learned how the group operates, it is rational for established
      group members to distrust them"
    </Highlight>
  - This happens all the time in OSS - many projects have core maintainers who
    do all the work, and a significant amount of gatekeeping by way of bluntly shutting
    down PRs or issues when they're disinterested in them. It's fair to say that
    for the contributors getting shut down, a steady and consistent participation
    in the project will help them get notice, but it can feel like an unfair hurdle,
    too. What might be a more equitable solution to this? Not empowering code owners
    as much? Adding an objective, third party moderator to make some decisions?
- All Contributors
  - https://allcontributors.org/
  - Recognize All Contributors Including those that don't push code
- On Contributors...
  - Again, I'm reminded of the madness of Hacktoberfest 2020 - lots of garbage contributions from people just trying to get a free t-shirt does not make for good OSS, good community, or good contributions.
  - &#8203;<Highlight>Bus Factor</Highlight> is the number of contributors in a project
    who would need to be hit by a bus for it to be in jeopardy. lol

# Part 2: How People Maintain

## Chapter 4: The Work Required by Software

- Software, once written is never really finished. Chasing the feeling of a "finished" app/program/site is something that took me FOREVER to get over. I never felt like I had done anything, because nothing ever got to the finish line. It turns out that the finish line doesn't exist, and a decade+ of building "incomplete" things was the catalyst that I needed to figure that out. As such, <Highlight>greenfield</Highlight> projects are "coveted" because they're a blank canvas, enabling us to chase that feeling of a fresh _starting line_ to point us to a goal that is always just past the horizon. It's a feeling of hope - and thankfully a beneficial one, as rebuilding software from scratch is often inherently beneficial. Neat.
- <Highlight>Free as in speech, not as in beer</Highlight> vs <Highlight>
    free as in puppy
  </Highlight> is a brilliant analogy
- <Highlight>
    By focusing too much on iterating upon their incumbent product, companies
    risk missing major opportunities for so-called "disruptive innovation,"
    which eventually replaces existing products. - Clayton Christensen in Book:
    The Innovator's Dilemma
  </Highlight>

- The anecdote about Sophie Alpert being offered $600 to **open a PR on someone's project** because it would draw positive attention is mind-blowing.
  - "Is this what it feels like to be an influencer?" - Sophie
- <Highlight>
    We can think of a creator's reputation as a "battery," or store of value,
    for attention. More followers mean more attention in the bank, but when
    people follow a creator they do so because they expect to receive more
    content. If creators don't produce anything new, their followers will
    eventually get bored and leave. Reputation, like software, requires
    maintenance over time.
  </Highlight>

## Chapter 5: Managing the Costs of Production

- Absolutely mind-blowing that at one point, cryptographic code was treated the same as munitions by the US government. Early developers of OpenSSL <Highlight>had to become licensed arms dealers to be able to write and "export" (i.e., distribute) their code.</Highlight>
  - This is an implicit declaration that certain types of technical solutions can be weaponized, and perhaps just as importantly that sometime in the past, some of our legislators had a reasonable understanding of this. In the US, at least, it's apparent that this is no longer the case. Don't believe me? Pull up a congressional hearing with Tim Cook, Zuckerberg, etc
  - Relatedly, it is asymptotically difficult for lawmakers to keep up with the changing pace of technology. There's a decent argument to be made for a citizen-run, or commons-run governing body for technical regulation, rather that trusting some crusty old white men from flyover states whose pre-government professional lives weren't the least bit technical.
- <Highlight>
    When software is in static state, **what if there is no free-rider
    problem?** When code is non-rivalrous, it only has first-copy costs, which
    the creator is intrinsically motivated to provide -- so the problem doesn't
    seem to lie in how many people **consume** it. For this reason, I'm
    skeptical of attempts to charge for access to information, whether it's
    newspaper articles or open source software.
  </Highlight>

- This hints at one of the most fascinating things about content creators online. Virtually all of the really, truly successful creators are driven by an enjoyment of creating and sharing -- and might not typically start creating as a business. Often times it takes hundreds of youtube videos, or dozens of podcast episodes, blog posts, etc to get any kind of sizeable following. It's those with the fortitude and perseverance to continue without an audience that find success. Perhaps the audience is their reward, or perhaps the audience is a natural byproduct of the law of large numbers: create enough of something, and put it out into the world, and **some size** of audience will find you.
- <Highlight>
    At a high level, it's also possible that throwing away projects and starting
    fresh is the most cos-effective approach: rebuilding the whole system, piece
    by piece.
  </Highlight>

- There are many companies that operate like this - occasionally dropping an existing product for a **completely new** rewrite. This has been done with projects as small as weather apps and as large as Windows and MacOS, and is often a good decision. It strikes me that this is often only possible due to a luxury of funding, time, and resources. Imagine telling a scrappy startup that their best bet is to ditch their entire source library, and start anew. It wouldn't work! Many fledgling companies fall apart because of early and inflexible assumptions made, or technical debt built up to save time. The luckiest of them find success despite this debt, and carry on to be successful. I'd imagine this success often brings about an effort to rebuild the plane while it's flying, in a modern Ship of Theseus paradox.
- Automation! This section rang true with me to the core. When building [smpl](https://www.crunchbase.com/organization/smpl-llc), our biggest superpower was automation. It made our engineering team of 2 feel much larger than it was, and helped us to execute successfully and dependably. To this day I think that process automation is the closest thing I have to a superpower.
- It's interesting that a book about OSS has me thinking about work, content, and contributions outside of software so often. So much of what's discussed here has interesting implications politically, socially, and in content creation of any sort for public consumption (art, blogs, youtube, instagram, etc)
- I didn't know about [dear-github](https://github.com/dear-github/dear-github) or its relatives [dear-github2](https://github.com/drop-ice/dear-github-2.0) and [isaacs/github](https://github.com/isaacs/github). It'll be interesting to give these a read. As of this writing, `dear-github2` has had activity as recently as 2 weeks ago

### The role of Money in OSS

- Companies pay for access, attention, and feature proposals. This can often have adverse effects: companies are essentially skipping the line to pay for attention, and as a result aren't vetted by the same processes as other OSS Contributors (particularly those who request fixes and features). This can be a governance nightmare, and can cause mistrust in a project if done incorrectly.
- Advertising in OSS projects has real untapped potential, but often gets shot down. There was a product called Code Fund by Eric Berry which aimed to put ads into the readmes of OSS repos on github. It rose to $24k/mo revenue in 4 months before GitHub shut it down as a violation of their ToS.
- Trivago appears as a sponsor on Webpack, and this has helped them to recruit JavaScript developers, who see them as a good company to work for as a result of their support.
- An interesting difference in funding projects comes by way of GitHub's sponsors feature (and other services like Pateron), whose goals are more oriented towards having individuals back a **contributor** (rather than a project) on a monthly basis. The subscription is seen as a vote of confidence in the person, rather than slippery backing for a single project.


Book notes: Working In Public

Chapter 2: The Structure of an Open Source Project

Chapter 3: Roles, incentives, and relationships

Chapter 5: Managing the Costs of Production


Put simply, [gitignore.io](https://gitignore.io) is a tool that is so profoundly helpful that I've _forgotten what life was like without it._

Its purpose is simple: for any project you're working on, it'll generate a valid [`.gitignore`](https://docs.github.com/en/rest/reference/gitignore) file for you. All you need to do is use the autocomplete box provided to describe the type of project you're working on:

<Image
  publicId="gitignore-fill-in-the-blanks"
  alt="Screenshot of the web interface for gitignore"
  border="2px solid #888"
  borderRadius="1rem"
/>

<Aside type="note">
  A <em>.gitignore</em> file is used to tell git to <em>exclude</em> files from
  being added to a given repo. Each line of the file represents a filename,
  directory, or pattern. When git looks for changes in your working directory,
  it will automatically ignore any file that matches an entry in your .gitignore
  file.
</Aside>

From there, you'll hit the `Create` button, which will bring you to a page that displays nothing but the raw text which you'll need to add to your project's `.gitignore`. If you selected just `react`, for example this is what you'd see on the next page:

```
  # Created by https://www.toptal.com/developers/gitignore/api/react
  # Edit at https://www.toptal.com/developers/gitignore?templates=react

  ### react ###
  .DS_*
  *.log
  logs
  **/*.backup.*
  **/*.back.*

  node_modules
  bower_components

  *.sublime*

  psd
  thumb
  sketch

  # End of https://www.toptal.com/developers/gitignore/api/react
```

That's all there is to it, too! I use it on the vast majority of projects I work on, new and old, and as far as I can tell, it hasn't let me down in any meaningful way.

## It's Open Source!

One of the reasons I like this tool so much is that it gets better the more people use it. Is it missing support for a project type that you work with? Go ahead and submit a [Pull Request](https://github.com/toptal/gitignore.io), and it may be integrated into the product one day. Or, if you're not quite comfortable with a full-on PR, you can start the discussion in an issue on the repo. Maybe something isn't working like you'd expect -- and it's worth pitching in your two cents in the discussion on an open issue. _All of that_ is contributing to Open Source -- don't forget!

As I understand it, it was created by [@joeblau](https://twitter.com/joeblau), and quickly gained momentum with developers. As I write this post, there are [**135** contributors](https://github.com/toptal/gitignore.io/graphs/contributors) on the project.

[Gitignore.io](https://gitignore.io) is a great example of a successful Open Source tool born out of the desire for an improved developer workflow. It currently appears to be operated by [TopTal](https://www.toptal.com/), a company that helps freelancers find work.

<Aside type="info">
  <small>
    (note for transparency: I have no connection to TopTal, and this is not a
    sponsored post. I <strike>do</strike> <em>(update: 11/2020) used to</em>{' '}
    work for{' '}
    <a
      href="https://aquent.com?utm_campaign=mikebifulco&utm_source=mikebifulco.com&utm_content=gitignore-io-is-great"
      target="_blank"
      rel="noopener noreferrer"
    >
      Aquent
    </a>
    , which is a creative staffing agency. If you're looking for work, give <strike>
      us
    </strike> them a look!).
  </small>
</Aside>

## There's a CLI

If you prefer it, there's a [CLI](https://docs.gitignore.io/install/command-line) which will help you generate gitignore files, powered by this same project. I can't say I've used it, but I know some of you will want to give it a go, so it's worth mentioning

## There's other options, too

If you don't find gitignore.io particularly appealing, there's always other ways to cretae your `.gitignore` file. You can write it by hand, or grab one from another project you work on. [GitHub also maintains a repo](https://github.com/github/gitignore) of popular gitignore files, which seems to be updated quite frequently as well.

### Was this helpful?

If you found this useful, I'd love it if you subscribed to my mailing list. Details are below!


gitignore.io is great


As of _this very post,_ I've added support for [MDX](https://www.gatsbyjs.org/docs/mdx/plugins/) to my site. It should make writing new content _much_ easier for me. By removing lots of process that has proven unnecessary, I'll be able to get back to writing more here, an I'm very excited about that.

And it works great! Here's an example of a custom shortcode I wrote, called `<Aside />`:

<Aside>These can be used to highlight important things.</Aside>

And the relevant code for Aside:

```jsx {1,3}
const Aside = (props) => {
  const theme = useTheme();
  return (
    <Box
      borderLeft="8px solid"
      padding="1rem 0 1rem 2rem"
      borderColor={theme.colors.pink[400]}
      backgroundColor={theme.colors.pink[50]}
      margin="2rem 0 2rem 0rem"
      {...props}
    />
  );
};
```

Its use is fairly simple, too -

```jsx
<Aside>These can be used to highlight important things.</Aside>
```

# h/t

This is on the heels of last night's (now defunct) Reactadelphia Meetup, where a very talented developer named [Prince](https://prince.dev/) gave a fantastic talk on MDX. I found it particularly inspiring -- it was that rare talk which had substance _and_ motivation. I already had a pretty good grasp of what one might use MDX for in practice, but Prince made some great points about why MDX is such a game changer.


MDX - I should have done this sooner


On my walk this morning, I found myself wondering what it's going to be like when things go back to normal.

If you've ever read the book Hatchet, there is a boy in the book named Brian who is stranded alone in the wilderness with only a hatchet for survival. I read it when I was in middle school - the main plot line in the book illustrates is how difficult solo survival can be. At the very end of the book is about Brian's experience going the grocery store for the first time after he's rescued, and what it feels like when he's thrust back into a world where the food at his fingertips is endlessly plentiful.

He suddenly sees the grocery store as a fruitful oasis of fresh produce, and snacks, and meat, and all the things he could ever want — thing that he just straight up didn't have while he was stranded alone.

What it's going to be like when the world comes back together? What are going to be the things that I have back in my life that I'll have missed?

I'm looking forward to finding out what my grocery store is. I'm looking forward to having something-like-normal back, and I'm looking forward to being able to appreciate those things.

Lately I’ve been trying to center myself on that.

I’d like to encourage you to center yourself on some of those things, as well as the things that you have right now that are going well (no matter how small they might be!). Hopefully, some things in your life are working out still.

For me, at least those things are the things that keep me going right now.

## There’s still great work being done

These are a few things I’ve found useful this week from far and wide

- 📉 [HealthData.org](https://covid19.healthdata.org/projections) has a frequently updated view of how each of the 50 states + DC are flattening the curve, as compared to hospital capacity. A remarkably well-done data visualization, but a sobering reminder of where we’re at.
- 🎨 [Dracula](https://draculatheme.com/visual-studio-code/) is a color theme made for VS Code (and many other editors) which is based on great color theory, and is frequently and lovingly updated.
- 🌲 [Ecologi](https://ecologi.com/irreverentmike?r=5d386c6667bad5001010ffae) is a wonderful service which will let you donate a couple bucks a month to offsetting your carbon footprint by funding the planting of new trees and other Gold Standard approved projects.

I hope you have a great day.

Talk soon!


On normalcy, daily routines, and the pandemic


<small>

_Note: I updated some names and links in this post. Dev.to's product became
**Forem** when it went open source_

</small>

So, like all good things, the idea for this post comes from a tweet:

<Tweet tweetLink="irreverentmike/status/1141169316273897536" align="center" />

This is something I've been ruminating on for a bit. I've even tried to build it - a few times! I keep starting in on the work and getting lost in the millions of directions I could take it.

Here's what I'd like: When I publish a new post to [my gatsby site](https://mikebifulco.com) (you're on it now!), I'd like for that post to appear on [dev.to](https://dev.to) automatically.

## It should:

- recreate my post verbatim, from its original markdown source
- use the `canonical_url` frontmatter field to make sure I retain SEO goodness on my post
- happen without my intervention
- be agnostic of where my posts are coming from. At the time of writing this article, I use [takeshape.io](https://www.takeshape.io) as a headless CMS for my site, so my individual posts aren't in source control
- only take posts from my `master` branch, since I use feature branches for draft posts from time to time
- use the [dev.to API](https://developers.forem.com/api) (update: now called the _Forem API_), of course

## Nice to have:

- maybe posts should be set to `published: false` at first, so I can preview/review/update them as needed for dev.to?

## Possible approaches for this:

1. Tap into GitHub's webhooks somehow, and fire off a post here
1. Come from a job kicked off after CI, maybe? I use CircleCI, but would like this feature to be fairly implementation agnostic.
1. Use a [GitHub App](https://developer.github.com/v3/apps/)?
1. ...or a [GitHub Action](https://github.com/mbifulco/thepraticaldev-crosspost-action)?
1. Perhaps just a lamba function deployed to AWS or [Netlify Functions](https://functions.netlify.com/).

So - here's where I ask for your help. Surely there's a simple approach here I haven't thought of, or maybe it's a matter of collecting a few scenarios and building something based on 80/20.

What else am I missing here? I'd love your help. What use cases would you have for a cross-poster from your gatsby site? How would you implement it? How can we help each other?


Do you have your own Gatsby site? Let's brainstorm a dev.to cross-poster


**Update (2021, pt.2): Do you want to know how to run Dependabot locally?**

I wrote a follow-up to this article based on a question I've been getting fairly regularly: How do you run dependabot locally? You asked, I answered - check it out here: How to [run dependabot locally](https://mikebifulco.com/posts/run-dependabot-locally) on your projects

**Update (2021)** Dependabot has been Acquired by GitHub, and many of the links from this post stopped working once they took down the original site (dependabot dot com). I've updated URLs here to point to more relevant links within GitHub's docs.

[Dependabot](https://github.com/dependabot) is an automation service that will automatically create PRs to keep your projects' dependencies up to date, and it is really powerful.

<Image
  publicId="posts/i-have-to-tell-you-about-dependabot/dependabot-settings"
  alt="Screenshot of the settings interface for a project on the former Dependabot.com"
  caption="Setup for Dependabot is flexible, quick, and straightforward."
/>

In just a few, sweet, wonderful minutes, you can install and configure it to automatically keep an eye on your project dependencies, and set a daily or weekly schedule to submit updates and changes. Automation at its finest - dependabot is like having a super mindful teammate who keeps an eye on npm (or pip or rubygems or one of [many other languages](https://docs.github.com/en/code-security/supply-chain-security/keeping-your-dependencies-updated-automatically/about-dependabot-version-updates#supported-repositories-and-ecosystems)) - you'll automatically get great, well-formed PRs for each dependency version bump, which you can test locally, or have sent up to your CI toolchain of choice.

After you run through the setup process, dependabot will monitor your repo and submit PRs to update individual dependencies on a daily or weekly rhythm (your choice!). If the PR contains an important security update, it will be assigned a label of Security, too.

<Image
  publicId="posts/i-have-to-tell-you-about-dependabot/dependabot-pr"
  alt="An example PR from dependabot"
  caption="Automatically created PRs are simple and to the point."
/>

Honestly, for me, it's like adding a member to my team. I love automation, and I love making my life simpler. Until now, for all of my projects, myself or another teammate would regularly run through all the dependencies in a given repo, and manually update them one at a time, testing and pushing them to GitHub to be run through CI and then eventually merged by the team. The honest truth is that this process can take quite a while, and can be forgotten, and isn't mindful of important security updates at all. That's all over now.

<Image
  publicId="posts/i-have-to-tell-you-about-dependabot/merge"
  alt="An example PR from dependabot"
  caption="Dependabot will merge this PR once CI is done, thanks to the @dependabot merge command"
/>

## What else?

There are a _ton_ of other features available to you the moment you install dependabot. It responds to a wide variety of commands by way of GitHub comment. In the screenshot above, I've approved a PR and asked dependabot to merge it as soon as CI has passed. Now I don't have to babysit the repo in order to merge updates! Sweet!

If your repo contains multiple languages, Dependabot can handle that. If you've got a complex monorepo with multiple files representing your dependencies (for example, a node project set up with Lerna), dependabot can monitor each dependency file individually, with different rules for each.

<Image
  publicId="posts/i-have-to-tell-you-about-dependabot/github"
  alt="Dependabot's announcement that they were acquired by GitHub"
  caption="Dependabot was acquired by GitHub"
/>

This was the final kicker for me. Dependabot was [just acquired by GitHub](https://github.blog/2019-07-25-one-million-dependabot-pull-requests-merged/), and is now available completely free for use. That's incredible! There's no reason for you not to give it a shot. Go check it out now, post haste!

Go install [Dependabot](https://docs.github.com/en/code-security/supply-chain-security/keeping-your-dependencies-updated-automatically/about-dependabot-version-updates)!

## For more reading

- Check out my follow-up post: How to [run dependabot locally](https://mikebifulco.com/posts/run-dependabot-locally)

_Note: the cover photo for this article comes from one of my favorite photographers, [Alex Knight](https://twitter.com/agkdesign), and was made available un [Unsplash](https://unsplash.com/search/photos/robot?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText). Thank you Alex for your work!_


I have to tell you about Dependabot 🤖


## I really don't like my laptop.

I've been using a 2017 Macbook Pro for the past couple years.  As I'm sure you've heard, it is a fiercely disappointing device largely due to its courageous lack of ports, flawed keyboard design, and astonishing sticker price.  My personal machine is a 13" version, with 16GB of memory, _no_ touchbar, and a 256GB SSD. When I bought it, upgrading to 16GB of memory seemed far more important splurging on processor speed or disk space.  That's probably still true - but I've found myself endlessly frustrated by the tiny capacity of the SSD in my day to day work.

Roughly once every 6 weeks, my machine grinds to a halt as I run out of disk space, so I have to suffer through all the usual suspects for clearing up some room:

- empty the trash
- delete unused applications
- make sure all my photos are moved to my NAS, cloud storage, and offsite archives
- remove old virtualbox VM images

## A new kind of purge

Last week, however, I came across a surprising new way to free up some disk space: clearing out `node_modules` directories.

Curiosity hit me, and I searched my mac for folders named `node_modules`. This is what I found:

- My machine has `7,731` _total_  `node_modules` folders.  Wow!
- Under `~/src/**`, where I keep all of my dev projects, I had a grand total of 7,719 `node_modules`
- These folders contain _hundreds of thousands of files_ (which should be no surprise), and took up nearly **10GB** of disk space!

## Turtles all the way down 🐢🐢🐢

That last number was a bit of a revelation to me at first.  If you're unfamiliar, `node_modules` contains a copy of each of the [npm packages](https://www.npmjs.com) which you add to your project (with `npm install` or `yarn add`, etc) on projects which use node.  Each of them are pinned to a specific version, which is typically specified in `package.json`.

Somewhat logically, each of the dependencies in your project's `node_modules` directory may also have a `node_modules` directory, containing their dependencies, each pinned to a specific version (again, defined in the `package.json` file of that dependency).

This is where file and disk space bloat happen - the libraries you add to your project may each contain dozens of dependencies, each of which have dozens more, etc etc, all the way down to super basic node and C libraries which make up the fundamental building blocks of node.

(Mind you - This is oversimplifying things a bit - depending on how you set up `npm` or `yarn` , there is _some_ optimization done here. If one version of a given npm module is required more than once by your dependency tree, it may only appear once.)

## The fix

Actually, this was pretty easy to fix.  I did a search for all of the `node_modules` folders under `~/src/**`, and deleted all of them, right from finder (sorry, terminal apologists).  I then emptied the trash on my mac, and I was 10GB richer.

<Image
  publicId="posts/reclaimed-10gb-of-disk-space-from-node-modules/disk-space"
  alt="Screenshot of MacOS folder info for a node_modules search"
  caption="10 GB of space, just for node_modules!"
/>

## What did it break?

It's been a week since I've done this. So far the only inkling of a downside is that when I revisit projects I'm actively working on, I need to run `yarn install` to recreate the `node_modules` directory there. I switch between a good handful of projects, and I'm back to a fair few directories, but at least these are just the ones I'm currently using. I'm good with that.

<Image
  publicId="posts/reclaimed-10gb-of-disk-space-from-node-modules/terminal"
  alt="Terminal search for directories called node_modules"
  caption="A week later, I'm back up to 1209 node\_modules directories"
/>

## Can we do better?

There is an alternative to `npm` and `yarn` called [`pnpm`](https://pnpm.io/), which claims to be a "Fast, disk space efficient package manager".  Its primary feature looks promising:

<Image
  publicId="posts/reclaimed-10gb-of-disk-space-from-node-modules/pnpm"
  alt="pnpm's value prop - one version of each package saved to disk"
  caption="One version of each module sounds great"
/>

I haven't tried it yet, but will certainly be giving it a shot.

## Epilogue 

I think it's fair to say that this is a problem that the folks at npm and Facebook (who maintain yarn) are also looking closely at. My guess is that some healthy competition will improve this disk space nightmare... hopefully before I'm forced to buy a laptop with 1TB of storage. 🥳

---

### More reading

I'm certainly not the first one to write about this.  Some more great reading for you to check out, if you're interested:

- [The node_modules problem](https://dev.to/leoat12/the-nodemodules-problem-29dc)
- [What Happened When I Peeked Into My Node_Modules Directory](https://medium.com/s/silicon-satire/i-peeked-into-my-node-modules-directory-and-you-wont-believe-what-happened-next-b89f63d21558) (this is the infamous tongue-in-cheek Guy Fieri article)
- [What’s really wrong with node_modules and why this is your fault](https://hackernoon.com/whats-really-wrong-with-node-modules-and-why-this-is-your-fault-8ac9fa893823?gi=1ff87c0f83ba)


I reclaimed 10GB of disk space from node_modules


# Dashlane
<Image
  publicId="posts/chrome-extensions-i-use/dashlane"
  caption="Dashlane password manager Chrome Extension"
/>

First thing's first - get yourself a good password manager.  I chose [Dashlane](https://www.dashlane.com/en/cs/mvKFbmiWCXxQ) (referral link) a few years back because of its security dashboard, which alerts you to your accounts which have been found in data breaches, any passwords you've used more than once, or passwords which are insecure.  Other great options are [1Password](https://1password.com/) and [LastPass](https://www.lastpass.com/).

  

# Elevate for Strava

<Image
  publicId="posts/chrome-extensions-i-use/elevate-for-strava"
  caption="Elevate helps me see how far I've ridden this year compared to years past."
/>

If nothing else, I am two things: a data nerd, and a [cyclist](https://www.instagram.com/p/Bqkko6CBtTu/).  I love cycling - it is my go to for exercise, meditation, and transport whenever possible.  Strava is the best service for aggregating GPS and biometric data recorded during cycling activities.  [Eleva](https://thomaschampagne.github.io/elevate/#/landing)[te](https://chrome.google.com/webstore/detail/elevate-for-strava/dhiaggccakkgdfcadnklkbljcgicpckn) is sugar on top of Strava - it adds a horde of wonderful data visualizations and progress measurements to the experience.  I frequently turn to the fitness trend tab to motivate myself to ride more regularly.  Did I mention that Elevate is [Open Source](https://github.com/thomaschampagne/elevate)? Heck yeah.

  

# FIO / Figure it Out

<Image
  publicId="posts/chrome-extensions-i-use/fio"
  caption="Screenshot of Figure It Out / FIO"
/>

One of the great luxuries of working in technology is being able to connect with people from wherever in the world you are.  In the past few years, I've been able to work from all over North America, Asia, and Europe, with folks spanning dozens of time zones.  I use FIO to see what time it is for my colleagues around the world.  With FIO installed, your new tabs in Chrome will show information about a collection of time zones (of your choosing), as well as a rough visualization of the state of daylight (or night light) where they are.  Brilliant!

  

# μBlock Origin

<Image
  publicId="posts/chrome-extensions-i-use/ublock"
  caption="uBlock Origin's README on GitHub"
/>

An ad-blocker that works reliably and quickly, and is [open source](https://github.com/gorhill/uBlock).  Be still my heart! uBlock stops annoying mid-roll ads on YouTube, and removes in-page ads from all over the internet.  Big quality of life improvement, and it's completely free.

  

# Toggl Button

<Image
  publicId="posts/chrome-extensions-i-use/toggl"
  caption="Toggl's use is simple: I use it as a timer for everything"
/>

I go through occasional phases where I track _all_ of my activities in a time tracker.  For me, the app of choice is Toggl, which is simple and intuitive, and lets me keep track of how long things are taking me via an app on my phone, their website, and this lovely browser extension.  It's clean and simple, and offers loads of integrations and customizations that might fit your productivity workflow, too.  The [Toggl Button for Chrome](https://chrome.google.com/webstore/detail/toggl-button-productivity/oejgccbfbmkkpaidnkphaiaecficdnfn) lives right next to the address bar, and stays out of the way when you don't need it.  I've gotten away with their Free plan for the most part - if you're using time tracking to bill customers, it's definitely worth looking at their paid features.

#productivity: 14 posts tagged