If you haven’t heard of “Don’t Repeat Yourself” or DRY, then I probably haven’t reviewed your code. Don’t write the same code twice. If you need to do the same thing in two places, it’s time to refactor and extract that code. This is a pretty simple concept but it’s also incomplete.

I have worked at companies that didn’t do this. What you end up with is copy/paste blocks in 10 places that all function slightly different. If one has a bug, you are unsure if the next copy/paste block has same bug. You spend your nights debugging why block Y isn’t working right just to find out it was actually block Z.

These days, if I see a request to merge and that merge changes the same line in multiple places, my stomach starts to turn. From time to time, it still happens. The culprit is usually either politics, management, or “the new guy”. Lately, the biggest culprit for duplicating code has been code generators, not people.

My introduction to code generators was in the late 2000s when I experimented with Ruby on Rails. Watching a tutorial “run this command…” and have a full “Hello, World” website up in minutes. This was appealing to me at a time when I was starting new projects every week but never finishing them.

The amazement was short lived, though, when I found out I made a single typo that propagated to 10 different places. Easy to solve: Restart from scratch, doing it right this time. If this had happened, and I had more than a seven-day attention span, the results would have been disaster out.

Another tool Ruby on Rails used was “ActiveRecord” which was my first understanding of dynamic metaprogramming as a concept.

For the uninitiated, metaprogramming is the concept of using a program as data for another program. Reflection is the subset of metaprogramming where a program uses itself as data.

The best example of the dynamic runtime reflection of Ruby on Rails is calling a method similar to “find_by_email” on an Active Record object. It would see the call to a function that didn’t exist and generate it dynamically based off the name and object, so:

• ‘find’: We want to find a (single) record of this type

• ‘by’: We want to find it using a field’s value.

• ‘email’: The field we want to use is ‘email’.

So now, with enough information to make a guess at what the developer is trying to do, the active record can make it happen. Does this seem to be DRY? Absolutely! We’ve now eliminated the entire collection of similar “find” methods down to one function, nested somewhere in a parent object.

This worked well for Ruby on Rails. Many languages even started to copy it because it works and is super easy to use. This only takes two features of the language to work:

1. Be able to know at run time when a call is being made to a method that doesn’t exist; and

2. Be able to know at run time what fields are available on an object.

Few features are required, but a few more features are needed to make it useful. First, Ruby on Rails is a dynamically typed language. While not impossible, the question of “How do you check the type safety of a method that doesn’t exist?” comes to mind. Tools like inheritance are also helpful to distribute these dynamic functions to objects.

While I absolutely love this type of dynamic metaprogramming as a hobby, it does not do well in big productions. The two big reasons for this are its speed and its reliability. While it can be done well, it can easily be done wrong. This is true of many things in software development, but terrible dynamic metaprogramming doesn’t show up when you compile your code, it shows up when you run your code. If you’re lucky, it happens when you run it, and not when your code is running on a production server you might not even have access to.

Skip forward about 12 years. I’ve now graduated, I’m out working for some big computer company writing tiny container packages in Go when I start working on an existing package that uses an interesting tool: go-swagger. The basics of it are pretty simple: given an API description, generate the rest of the code necessary such that you can just add in the implementation details.

go-swagger is another example of code generation. The output is executable Go code as the Ruby on Rails example above was Ruby code. The distinction is the input. While Ruby on Rails relied on long bash commands, go-swagger uses a YAML or JSON file for data. With this one minor change, you can now re-run the generation. Changes to the API are likely to happen so this is very helpful.

It wasn’t too long after working with go-swagger that a change to an API had to be made. Dozens of files were being changed because of one minor tweak. Is this DRY? Has code generation just removed the idea of “refactoring when you need to repeat your code” and exacerbated the problem using automation? And more importantly, why was this a good thing?

Coincidentally, around the time I was hunting for bugs in copy/pasted blocks A and Z, I read the seminal book “The Pragmatic Programmer” by Andy Hunt and Dave Thomas. This book is where “DRY” comes from. They actually publish the DRY chapter of their new ‘20th Anniversary’ edition as a sample and I’d definitely recommend reading both it and the book.

Unfortunately, I had missed a critical idea in the chapter about DRY. It’s subtle but it’s even in the definition of DRY.

“Every piece of knowledge must have a single, unambiguous, authoritative representation within a system” — Andy Hunt and Dave Thomas; The Pragmatic Programmer

Do you see it? It doesn’t actually mention code. It’s about knowledge. What does that mean? It means this isn’t about refactoring code. It’s about refactoring knowledge, which is a superset of your code. More specifically, “knowledge” in this case can refer to everything from the SQL you use, the API you’ve designed, the objects you’ve programmed and even the documentation you write.

So how does this apply to our go-swagger generation? Simply put, there is only one “authoritative representation” in the system, and it’s the API documentation. The API documentation should systematically influence the program’s design when possible.

Why doesn’t go-swagger just dynamically read the API description and produce a functioning API at runtime? Go is a very light-weight, performance oriented and statically typed programming language. While it would absolutely be possible of any language, it would not necessarily be useful when considering performance.

Go has evolved into a language of small, sharp tools. Its focus on small directory sized packages helps to make code reusable and easy to read. Packages are statically typed, and “nothing is hidden”. There’s no magical construct methods that happen to perform random tasks when you create objects. Constructors seemed so obvious that the thought of a language without them seemed almost archaic when I started to learn Go.

Code generation provides metaprogramming to a statically typed programming language in a performant way. go-swagger does this using a set of library packages for the parts that don’t change based on API, and a structured set of implementation functions and data models used for the parts that represent your API. This is a great approach as changes to the library packages don’t need to interrupt the implementation details.

For people fluent in Go, the idea of loading a monolithic package for slowly building dynamic functionality like Active Record does is completely asinine. Some ORMs do exist for Go, but you can’t go more than two comments in to a discussion before someone tells you to just use this or that SQL helper and be done with it.

So what about using go-swagger’s YAML to Go generation approach to SQL Database management? Well, it exists. There are a few different packages like sqlingo or xo that allow you to generate Go code from your Database scheme. But what if you wanted to use both this SQL platform and go-swagger together? That wouldn’t be DRY, as now you have two separate bodies of knowledge that can conflict: Your database and your API. I like to think of these as “outside-in” approaches, as outside parts of your program dictate or generate what’s going on inside.

Recently, I began working on a project that involved Kubernetes, and some of the Kubernetes tools generate scaffolding and YAML files. The interesting thing I noticed about these tools was that this was the opposite of the go-swagger approach. They were producing YAML by scanning Go code. You can place “markers” — fancy comments — in your code, and the controller-gen tool reads the comments and related code and produces your YAML.

The controller-gen approach was helpful because it had one “authoritative representation” in the system and that was your code. This was an “inside-out” approach, as the code dictated what the YAML would look like, just by existing as code.

This led me to a thought experiment: What would this “inside-out” authoritative representation approach look like if it was done in its entirety? Well, it would start with some simple Go models mixed with tags, markers, and documentation. The documentation and the model would generate into an API description, and the model would generate into a SQL Database and a set of helper functions.

go-swagger does allow something similar to this. It allows you to have comments in your code that will generate your API description. This approach is very similar but it’s missing one critical piece. It can’t get all of the content from your code. It does require you to duplicate the knowledge about which API routes do what.

As for SQL? I haven’t yet found a tool that does this. I have found plenty of SQL Builders, I’ve found a few SQL to Go generates, but I haven’t found anything to build my SQL for me.

Resources

Ruby on Rails

The Pragmatic Programmer — Andy Hunt and Dave Thomas (20th Anniversary Edition)

DRY chapter of The Pragmatic Programmer, ‘20th Anniversary’ Edition

The Go Programming Language

go-swagger

Kubernetes

Code Generation is Terrible; I Love It was originally published in Geek Culture on Medium, where people are continuing the conversation by highlighting and responding to this story.

One of my weaknesses is “gardening.” No, not the dirt and flowers kind—though I’m sure that’s fun for the same reason.

“Gardening” is the detailed work done after writing and testing code. It is similar to refactoring—reorganizing code to make it more efficient, reusable, or readable—but at smaller scales. Gardening helps ensure the code has consistent naming, syntax, and documentation and that the code is in compliance with the style guide.

Paying attention to the minutiae of the code is a requirement for programmers. One misplaced semicolon or one missing equal sign, and you could spend hours debugging.

This is not my weakness.

For me, tending to the code’s minutiae is fun. I enjoy it immensely. But, this is the problem. Knowing when “enough is enough” has always been my weakness. I can spend hours aligning brackets, renaming things, and writing excessive documentation.

This compulsion to detail has caused simple tasks to grow so big that I give up.

So, what to do?

If I don’t clean up my code, the code becomes an incomprehensible mess. Messy code is hard to understand. Code that can’t be understood is not able to be maintained. Unmaintainable code is discarded.

Not cleaning up code impacts development in ways that affect business. The effects range from simple bugs to preventing delivery, all of which are opposed to revenue.

If gardening is enjoyable for me, removing it from development reduces the reward. I’m less likely to do software development if I don’t enjoy at least some aspect of it.

But if I kept getting stuck in the details, the business results would be affected immensely.

I needed a system.

Here is what I came up with: defer the fun stuff. Not indefinitely, but to when my motivation and energy are lowest.

My energy, focus, and motivation are usually highest before lunch. It slowly weans until around 4 PM, and by the time my kids are in bed, all hope of getting anything productive done has disappeared.

I tackle the big tasks like designing and implementation before around 2 PM. The last few hours of work or after my kids have gone to bed, when I’m tired, with a brain as sharp as playdough, I go through the list so I can still contribute.

The hard part becomes deciding what to defer.

What do you do to keep yourself moving forward? What systems have you created? Reply and let me know!

Thanks for reading!

Summary: You don’t need expensive keyboards to improve convenience. Complete customizability is excellent, but we can get halfway there with simple soft-hacks. You can use system preferences and software tools to customize your keyboard to make your navigation more comfortable and help prevent errors.

Whether you’re on a computer all day or just trying to do something quickly, you’ve probably realized that switching between the keyboard and mouse can take a moment. Added all together, these moments can eat up a chunk of time. This wasted time is terrible for productivity and gets even worse if you touch type and manage to miss home row.

This latency is a known limitation of most modern operating systems, and as such, there is a solution: keyboard shortcuts. Keyboard shortcuts present problems as well. Most of them are designed to work for general problems and are not optimized. If you’ve ever typed Command + Tab, Tab, Tab, Tab, Tab, you know what I mean.

Remembering keyboard shortcuts can be a daunting task. Like most things, the key to remembering them is using them. Generic ones like Copy and Paste are usually pretty easy to remember. Creating custom cheat sheets for each app you use can also be quite handy. Then there’s the option to customize them.

When is a keyboard shortcut not a shortcut?

Has this scenario ever happened to you? You’re switching between applications and closing them as you go. You think you have iTunes open (Did I connect my phone?!) so you go to close it using Command + Q, nice and simple. Except you just closed a window with 5+ tabs open. Oops.

All of a sudden, that “shortcut” isn’t much of a shortcut anymore. Luckily, there is a way to disable this for specific applications. If you go to System Preferences and click on Keyboard, you’ll see a Shortcuts tab. If you create a shortcut for the “Quit [Application Name]” menu item, any existing shortcut for that menu item is not triggerable. Note that you’re going to want to make sure this matches the menu item, not the name of the application. For example, when you open iTerm, it shows “Close iTerm2”, not “Close iTerm”.

In my case, I added this to Safari and iTerm. I can sit in my iTerm window and press Command + Q or Command + W and nothing happens.

When is a keyboard not just a keyboard?

A few years ago, when I was working at a contact centre, I decided to purchase a mechanical keyboard. Mechanical keyboards quickly grew into a hobby, and after about five keyboards I had found my endgame, the beautiful 40% Planck Keyboard from OLKB. When is a keyboard not just a keyboard? When it is a piece of art.

One of the main benefits of the Planck is that it runs on the QMK firmware which offers endless amounts of customizability including changing the key map. I wrote an article about it, including my keymap. The Planck is a fantastic keyboard, and I learned some of my favourite “desire paths” from it.

My only issue was that I needed to move from my desk to the meeting room. I frequently found that switching between the Planck and the built-in MacBook keyboard became confusing for my hands. However, there was no way to add this functionality to my MacBook keyboard. Or so I thought.

When is a key less than a key?

If you’re a terminal junky like me, you probably use the Control key a lot. As said before, keyboard shortcuts are a great way to avoid switching to the mouse, but in the simplified, often mouse-less environment of a terminal, they become even more critical.

I could write an article on just shortcuts for Bash/Zsh. (That’s not a bad idea. Look forward to that in the future.) The majority of bash shortcuts, along with many used for terminal programs like tmux and Vim use the Control key. The notable exception is the Escape key for Vim to enter “Normal Mode”.

As a side note, Vim’s “Enter Normal Mode” shortcut is generally Escape, but Control + [ also exists which works faster.

So, if the Control key is so important, how come it is such a stretch to reach? If you think you know why, please add a comment below. Terrible placement aside, there is a solution. And a pun, but you’ll get that in a moment. Deep inside of the System Preferences, Apple does let you adjust this.

You may have noticed while using terminal-based apps that the Home Row comes up often. The home row is the position where your hands should be at rest. Being able to put the most critical keys on this row is helpful, which is why Vim loves it so much. The Home Row contains one of the most useful keys for terminal use: the Return key, as well as one of the least useful: the Caps Lock key.

The Caps Lock key is useless in this day and age unless you find yourself in YouTube comments. It’s likely one of the few keys that’s actuated more often by accident than intention. I’m sure you can see where these two areas collide. Let’s convert that prime real-estate Caps Lock into something actually useful.

In System Preferences, open the Keyboard panel and click on the “Modifier Keys…” The modal that opens gives us some customizability. We can select to set the “Caps Lock” option to the value of “Control”. Here’s a gif, because it’s not 2005 anymore and static images don’t cut it.

Okay. So we’ve upgraded some dead space. One other thing you may have noticed is that there was another option in there. You can set the pressing of the Caps Lock key to an “Escape” press. Setting the “Caps Lock” setting to the “Escape” value is very tempting. If you have one of Apple’s Touch Bar MacBook Pros, “Escape” may even be a better choice. I did this for a while, and I can recommend it as much as the “Control” option. Of course, we can do one better.

Side note for Apple, if you’re reading this. I love the Touch Bar. It would do well above the function keys on a pro device though.

When is a key more than a key?

It’s about time we introduce the real star of this article, Karabiner Elements. Self-described as “A powerful and stable keyboard customizer for macOS,” I decided to put it to the test. I enjoyed the outcome, and I think you will as well.

Karabiner Elements is very similar to the “Modifier Keys…” prompt in the same way a Formula 1 car is very similar to a bicycle. In its “Simple Modifications” tab, Karabiner allows you to switch any key to act as any key. Did I mention this was the “Simple Modifications” tab?

”With great power there must also come — great responsibility!” RIP, Uncle Ben.

While there are eight tabs total, the first three (Simple Modifications, Function Keys, and Complex Modifications) are the ones we will discuss. If you wanted to, you could easily repeat the same modification, converting the Caps Lock key to a Control key when pressed.

The “Function Keys” tab is quite helpful as it allows you to change what the functions labelled on the keyboard do. Perhaps you don’t like Launchpad and want to have a regular F4 without changing the rest of them?

The “Complex Modifications” tab is where things get crazy. What if a key could do different things based on the context of its use? Here are a few examples:

Application Specific:

Perhaps your IDE forces you to use Shift + F4 but you don’t use F4 for anything. You can have Karabiner force all F4 presses inside of your IDE to be Shift + F4 for you.

Multi-Modifier Keys:

If you’ve read my post on Alfred, you may have noted that you can make advanced workflows start from a keyboard shortcut. If you’ve looked through the keyboard shortcuts in your apps, you’ll notice there aren’t a lot of options left that give you flexibility.

For example, if you cycle through the same five apps regularly, all day, your pinky finger may get tired from tabbing between apps. Let’s add our own: introducing the makeshift Hyper key!

The makeshift Hyper key is technically a combination of Control + Option + Command + Shift. Pressing Control + Option + Command + Shift + C to open Slack would be kind of annoying. Well, let’s change a key to be the Hyper key. In this case, let’s set the right Command key to be our Hyper key. After updating Alfred to open apps using keyboard shortcuts, I have set the following:

• Hyper + C to open my Slack Chat.

• Hyper + K to open my Kanban board.

• Hyper + G to open my Gitlab.

• Hyper + M to open my Spark Mail.

Realistically, your memory is the soft limit for this.

Differentiate between modifier and lone key presses:

This customization is elegant, and probably my favourite part of Karabiner. A key can be a key when pressed by itself, but another key when used as a modifier. For example, let’s set our ill-suited Caps Lock key to be Escape when pressed alone, but count as Control when pressed with another key.

So now pressing the Caps Lock key is equivocal to pressing the Escape key. However, pressing Caps Lock + P is equivocal to pressing Control + P. Just think of the Vim possibilities!

To do this:

1. Open the “Complex Modifications” tab in Karabiner.

2. Click on “Add Rule”.

3. Click on “Import more rules from the Internet (open a web browser)”.

4. When the browser opens, search for “Change caps_lock key (rev 4)”.

5. Click “Import” for the option listed. Once imported, it’ll show you all the available rules to select.

6. Find “Change caps_lock to control if pressed with other keys, to escape if pressed alone” and click “Enable” next to that.

Done!

Even More Craziness

There are even more things you can do, as well. Here are some examples:

• Double-press a key to result in an event.

• Press-and-hold a key to result in an event.

• Use multiple non-modifier keys to result in an event.

The Ugly Side of Karabiner

One thing I’ve found difficult about Karabiner is that it’s documentation for Complex Modifiers is hidden under the karabiner.json reference manual menu item. Once you have created a complex modifier JSON file, you need to import it. At the time of this article, there is no way to import JSON files directly. To import the file, you need to use the URL karabiner://karabiner/assets/complex\_modifications/import?url={URL} where the {URL} is the full path to the JSON file starting with file:///, URL-encoded.

For example, assuming the file is at /Users/username/Documents/Modifier.json, we change it to file:///Users/username/Documents/Modifier.json, and then encode it as file%3A%2F%2F%2FUsers%2Fusername%2FDocuments%2FModifier.json and prefix it with the rest of the URL as karabiner://karabiner/assets/complex\_modifications/import?url=file%3A%2F%2F%2FUsers%2Fusername%2FDocuments%2FModifier.json.

Example karabiner.json file

<a href="https://medium.com/media/8ebf863e8b25b71d515eacb19089954b/href">https://medium.com/media/8ebf863e8b25b71d515eacb19089954b/href</a>

Wrapping It All Up

These changes represent my own needs. So now we have:

• Removed keyboard shortcuts that cause more harm than good;

• Single keyboard shortcuts to open apps and web pages;

• Moved some of our most commonly used keys into better locations; and

• Set up our environment to be able to do even more.

I hope that this article has given you the confidence to create your shortcuts and help speed up your work. If you have created some shortcuts, let me know in the comments below!

Summary: Alfred is a neat macOS app at first but crazy powerful once you understand it.

Sometimes the hardest part about getting work done isn’t the challenging bits. It’s the boring parts. You know the ones. Writing up a pull request, or navigating to tickets, etc. Sometimes it’s hard to get rid of these things. If you can, that’s great. If you can’t, there’s Alfred.

After using Shortcuts on iOS and discovering my new love of making workflows to automate my busy work, I decided to have a search for a comparable tool for macOS. Automator on macOS is an excellent start but lacks the ease of use of Shortcuts. For years I was convinced that Alfred was a moderately improved Spotlight search and therefore not worth the money.

🤵First Servings

After installing Alfred and starting to configure it, I knew that I was wrong. Where Spotlight does a decent job of searching files, Alfred is a tool for performing actions of many different types, one of which happens to be an ultra-fast search for files. Alfred is highly configurable and going through its exhausting preference panel helps tell you something about the number of actions available.

Here are some of my favourites. These are built-in by default, and I use them almost daily:

Clipboard History: If you’ve ever had to deal with copy-and-pasting two things at once, this solves that problem elegantly. After typing in the keyword (default of clipboard, I switched mine to pb), or pressing the keyboard shortcut (Alt + Command + C), you get a list of the most recent things you’ve copied. Command + 3 pastes the second most recently copied. Alfred is even smart enough not to store passwords from 1Password or Keychain in the clipboard history.

Snippets: The reason that Command + 3 returns your second copy is because of snippets. They’re the first result. If you’ve ever had to copy and paste a template before filling out the specific details, you know how annoying it is to do it again. Snippets are the solution to that. You can paste the template into a snippet and then use the keyword snip to search for it. An example of this would be using “Merge Request” templates. I can open Alfred Command + Space and then type snip merge and press enter. The field populates.

Web Search: By default, Alfred has searches for many popular websites setup. You can easily search IMDb Avengers to find out more about the Avengers movie. Where this gets really good is that you can add your own custom searches. For example, I have my work Wiki setup using wiki issue login fails on error to search for any issues containing that text. You can make this even more powerful, but we’ll get into that below.

Want to add a new web search? Just go to the site you want to search, type in {query} and do a search. Replace the part of the URL on the results page that says %7Bquery%7D with {query} and then add the URL as a new entry to the table of searches. Here’s an example where I added in a Python search in about a minute:

If you have or plan to add your own search, what will it be for? Comment at the bottom. I’d love to hear about it!

Web Bookmarks: Similar to Web Search, Alfred can search for and open your bookmarks. Even better than that, it can open them in the browser in which the bookmark exists. If you deal with terrible intranet sites that should have been purged a decade ago, this is amazing. A quick search for (or if you have it set, a keyword followed by) þe olde SVN opens an instance of Chrome when one is warranted. Unfortunately, the bookmark search only works in Safari and Chrome. You can have pages open using Firefox, but we’ll get into that below. (Is the suspense killing you yet?)

The Rest: Calculator, Dictionary and Contacts are all improved over Spotlight. Alfred also includes actions for controlling iTunes, the entire macOS system and even the ability to run terminal (Terminal.app, iTerm or Hyper, theoretically more) commands directly, opening a new window with the result. Pretty neat, eh? Let’s get to the cool part though: Workflows.

If you have used Alfred before, what was your favourite feature? Was it one of the ones I listed or something I may have missed? Comment at the bottom. I want to hear from you!

🏗 Workflows

Everything up to this point has been pretty neat. Workflows, though, take this app from nice-to-have to productivity-enhancing-drug. Workflows, as the name implies, are a way of performing one or more actions as easily as possible.

There are five parts: Triggers, Inputs, Actions, Utilities and Outputs. Triggers and Inputs start a workflow before handing off to Actions or Utilities (which may also trigger other Actions or Utilities), finally ending in an optional Output.

It seems simple enough. So why all of the fuss? All five of these parts offer a lot of different options.

🚦 Triggers can be hotkeys, other Alfred features, or an external trigger (which generally means using AppleScript. Expect more on that in another article!). Think hitting Command + Alt + V or running a Bash command. These don’t even need to be you running the trigger, either. You can use tools like fswatch to run it whenever a file is updated.

⛽️ Inputs are keyword-based actions that may have a query. Use these when you’re trying to use Alfred similar to Spotlight. “Keyword” works for simple actions like typing in keyword [query...]. For example, I have one set up so git jakew/dotfiles opens github.com/jakew/dotfiles, which makes getting to the project on Github super easy.

Another significant option for Inputs is a Script Filter. This one allows you to run a script and return the results directly in the Alfred window. It can run Python, PHP, Ruby, Perl, AppleScript or even just a Bash function. Returning JSON or XML in the proper format allows Alfred to show a custom list of results. For example, I have a Python wrapper that returns all of the tickets I own in my organization’s issue tracker. By typing issues, the list is populated and selecting an option opens the issue in my browser. (Unfortunately, my issue workflow uses proprietary software so I can’t release it. 😫 Just know that it would have blown your mind.)

🏃‍♀️ Actions are generally the doing part of the workflow. For example, they might open a specific app, file or URL, or run a system command. An Action can also run an AppleScript script for automation purposes. You can combine it with applications that use x-callback-urls as well (which is itself a topic for another article.)

🧰 Utilities are the logic of the workflow. If query is this, then do that. Split arguments. Convert X to Y. Stuff like that. One extra utility available is “Debug,” which shows you the current values in your workflow objects.

📺 Lastly, Outputs are how you get the content or notification out of the workflow. It can be as simple as a macOS Notification or sound, or it can itself trigger a key combination. Outputs may also write text where your cursor is currently waiting, or put its result in your clipboard, ready for you to paste. To get even crazier: an output may also call an “External Trigger”! Remember when we mentioned those above? Yea, you can have workflows calling workflows. 😱

❤️ Sharing is Caring; Sharing Automation is Doubly So.

“Okay, you’ve convinced me,” you might be thinking, “but do I want to sit down and make all of these workflows?” The simple answer is: you don’t need to. A large community of people are already making a lot of them and are eager to share! You can join in on the Alfred Forum and even share the workflows you’ve made.

You can also get workflows from the Alfred Blog or even in future articles on Effective Dev. Here is an example of one I’ve already made:

• Paste as Code Block: When “pasted,” the contents of your clipboard paste with three grave-accents (```) surrounding them to create a code block. Pasting like this is helpful in Markdown on Github/Gitlab, and in Slack.

If this article has convinced you to get Alfred or if you already have it, and you have made some workflows of your own that you’d like to share, I’d love to see them in the comments below.

🏁 Conclusion

Alfred has been amazing for increasing my productivity. As long as I don’t spend my entire day making workflows instead of doing work. Alfred can get many things done, so you don’t have to. Its community is vibrant and offers a ton of resources that you should check out. Of course, your workflows are your own, so dig in and give it a try.