Effective task management with Things

| 7 min read

Ever since Things 3 came along, it’s been my todo app of choice. Every now and then I check out the competition, but I always swing back.

Inspired by Stefan Zweifel’s post, here’s how I use Things on a daily basis.

Read more


Caption images with markdown render hooks in Hugo

| 2 min read

I’ve been looking for a way to add captions to markdown images without falling back to raw HTML. It turns out Hugo supports this with render hooks.

Read more


Middleware as a Laravel service provider

| 1 min read

When you need to set up a service in a Laravel app, service providers are generally the place to be. But, there’s one problem with service providers: they’re global. This usually doesn’t matter, but in multi-section apps this can be problematic.

Read more


Zipping

| 1 min read | Unix things I always forget 3/7

Zipping is easy. Remembering zip's arguments is hard.

Read more


Unlearning

| 1 min read

As developers, we often talk about the importance of learning. Learning is so important to us, that it’s worth persuing ways to improve the way we learn.

One way to become a better learner is to master the reverse: unlearning. Not the ability to completely forget, but the ability to set something aside for a brief moment.

When we learn a new language, framework, or tool, it’s hard not to dismiss new ideas based on our existing opinions. It’s the mental baggage we carry along all day.

What we’ve established as antipatterns in tool X’s, might be shiny tool Y’s bread & butter. That doesn’t mean we should dismiss tool Y. Ideas on their own are rarely good or bad, they need to be evaluated in a certain context.

Read more


Builders and architects

| on stitcher.io

My colleague Brent wrote a food-for-thought post about two different kinds of programmers: builders & architects.

The first ones, the builders, are the programmers who get things done. […] On the other hand there are architects. They are concerned about sturdy and structurally sound code. […]

These two types of programmers seem like opposites. They themselves look at the other group and often think exactly that. They have a different way of handling the same problems. The other group’s solutions are so different, they can’t possibly be right, or so it seems.

Builders often find architects too rigid and conservative. They follow the rules for the sake of following them, without any practical benefit. Architects in turn, think of builders as careless, too focused on results, instead of thinking about long-term maintainability.

Different programmers aside, “build vs. architect” is the eternal internal conflict when I want to make decisions. Striking a balance between “getting things done” and “getting things right” is tough.

Read the entire, beautifully illustrated post on stitcher.io.


Complexity has to live somewhere

| on ferd.ca

By Fred Hebert:

  • if you make the build tool simple, it won’t handle all the weird edge cases that exist out there
  • if you want to handle the weird edge cases, you need to deviate from whatever norm you wanted to establish
  • if you want ease of use for common defaults, the rules for common defaults must be shared between the tool and the users, who shape their systems to fit the tool’s expectations
  • if you allow configuration or scripting, you give the users a way to specify the rules that must be shared, so the tool fits their systems
  • if you want to keep the tool simple, you have to force your users to only play within the parameters that fit this simplicity
  • if your users’ use cases don’t map well to your simplicity, they will build shims around your tool to attain their objectives

The endless loop of software development. Complexity is why what starts out as “a lightweight alternative to X” often ends up as bloated as X. Greenfield projects allow you to not care about the edge cases for a while, but complexity always catches up.

Read the full article on ferd.ca.


Refactoring callbacks to async/await

| 1 min read

Web browsers have a few functions that accept callback parameters. setTimeout and requestAnimationFrame are the first that come to mind.

If you need to do multiple calls to these functions in a row, you quickly end up in callback hell. Here’s a quick tip to flatten your code with async/await.

Read more


Enter & leave transitions

| 5 min read | JavaScript Framework Diet 7/10

Now that we’ve built a dropdown list, lets add some transitions to create open & close animations.

Read more


Shotgun upgrade your npm dependencies with yarn upgrade --latest

| 1 min read

Every now and then I do a quick checkup of a project’s npm dependencies. I like to keep them up to date by often doing small upgrades. It’s a lot less painful than doing large upgrades once a year.

One annoying part of this process is ensuring every dependency is on the latest major version. For example, if a project requires lint-staged@^8.0.0, yarn upgrade won’t upgrade it to lint-staged@^9.0.0 (luckily of course, it’s the behaviour I want during everyday development).

Today I learned about yarn upgrade --latest, which will upgrade all dependencies to the highest available version, despite the version constraints in your package.json file. lint-staged@^8.0.0 would happily upgrade to lint-staged@^9.0.0, even if it breaks semver boundaries.

Read more