Unlike Apache and Nginx, Let’s Encrypt has no way of autoconfiguring your Node.js app, as it can work in arbitrary ways, while the
former two usually follow a predefined (and machine readable) configuration.
Let’s Encrypt works great with Supervisor, as it provides easy orchestration and some basic scheduling that the certificate
management requires. Configuring it is also not rocket science; just identify the environment your app is running in,
and choose a suitable workflow. This can even be done with minimal changes to your app, and in a Docker-friendly way.
Docker is a great way to componentize an app along different aspects. But I found that when I still need to start multiple
programs in a single container, it is better to use supervisor instead of cron scripts.
Hooks are the main elements of adapting certbot to your particular use case. I found a few application setups that depending
on whether you can support authorizations while your app is running or not, there are different kind of hooks you
Why some projects are clean, easy-to-read, and performant, while others a convoluted mess? Why, when making a modification, in some codebases everything falls into place immediately,
while in others it’s more like walking on a minefield?
As WebPack 2 barrels forward, Tree Shaking — or more technically, the removal of unused exports using static analysis — is finding its
way to the mainstream. Developers are putting their hopes high, as it promises to solve the pressing problem of bloated packages. Usually,
only a fraction of code is actually needed from each dependency but their entire codebase is bundled, increasing the size.
There’s a lot of buzz about JVM optimizations and how it makes production code perform better
thanks to the Just-In-Time (JIT) compilation and various optimization techniques.
A lots of excellent research materials are available,
but I wanted to see for myself how these apply in practice,
so I decided to dig deeper and play around with some measurements.
The single biggest obstacle of understanding a piece of code is a lot of variables. Variables
introduce state, which in turn increase complexity exponentially. Every single bit of variable information
makes reasoning and understanding the code harder.