The main security issue in the modern world is identification. How can we be sure that the person we are corresponding with or exchanging files with is really who they claim to be? How can we be sure that the files we receive have not been altered along the way? How can we be sure that the files we receive were actually sent by the person who sent them?

These questions are solved by signing the data being transmitted. A signature is some information that is generated using a private key and can be verified using a public key. If the signature is correct, then the data has not been altered in transit and it was sent by the person who sent and signed it.

Once again, I come across the situation where our infrastructure becomes a mess, and we migrate everything to Terraform, and in the latest iteration, to AWS CDK. But then the real mess begins. Eventually, everyone is afraid to make any changes, fearing that something might break, and as a result, nothing gets changed. The snowball keeps growing and becomes increasingly unmanageable. At some point, I got tired of it all and decided that we need to bring order, but in the least painful way for the developers.

We decided to go back to Ansible for automating small tasks needed to manage our infrastructure. In this case, the fear of causing harm was much less, and the code became more readable and understandable. Overall, I enjoyed it. So I decided to share my experience with you in creating such small playbooks for managing our infrastructure. In this article, we will create a VPC using Ansible.

When we build a Docker image of our application, we already know which version of the application will be in it. But often we don’t bother passing this information inside the container. Especially when it comes to web applications. However, this can be useful. For example, for error monitoring, it will definitely be helpful to know which version of the application crashed and when it was built.

In this article, I’ll explain how to pass information about the application version inside the container. This applies to applications in Go as well as web applications in Node.js. I’ll also show how to use this information inside the container.

One of the important skills that a programmer should possess is the ability to estimate task completion times. Estimating work durations plays a key role in project planning, as well as ensuring the realism of goals and commitments to managers, colleagues, and users. However, there are often misunderstandings regarding the concepts of estimation and commitment, and their differences are not always clear. I have experienced both sides of this issue and know firsthand how harmful it can be to a project. Therefore, I decided to write this article to help programmers and managers understand this issue.

Recently, there’s been increasing emphasis on website performance. It’s no wonder, as people have become more demanding about the speed of website loading. Therefore, it’s crucial to monitor your site’s performance. This can be done using Lighthouse.

Lighthouse is a tool for analyzing web page performance, and Netlify provides the capability to run Lighthouse for each deployment. This is very convenient as it allows you to track changes in your site’s performance. By default, Lighthouse runs only for the homepage. But what if you need to assess the performance of other pages? In this article, I’ll explain how to do that.

I came to Go about a year ago. I write in it in my spare time and I like it. I think it’s a very good language for both beginners in IT and those who already have programming experience. To date, I use Go in my personal projects and in professional work.

After a year of using the language in production, I can confidently say that Go has only shown itself from the best side. Having mainly Javascript developers in the team, I had no difficulties in introducing them to the course of things. The readability and simplicity of the language allows you to quickly understand the code. But I wouldn’t say that Go is a simple language.

To write my articles, I use Hugo, which is one of the most popular static site generators. It allows me to focus on writing content without getting distracted by technical details. Additionally, I use GitHub to store and manage the source code of my website. This enables me to easily track changes and make edits anytime and anywhere.

In this article, I will explain how I created my website using Hugo and optimized it for my own needs.

I wanted my site to be available under the following names: andrew.molyuk.com and molyuk.com, and I couldn’t achieve this on GitHub Pages. So, I decided to use Netlify. As it turned out, deploying Hugo on Netlify is very simple. In this post, I’ll tell you how I did it.

First, we need to create an account on Netlify. After that, we need to create a new site. Click on the “Add a new site” button and follow the instructions. Basically, that’s all we need to do on Netlify to make the site publicly available.

Always dealing with the server and architectural components of web applications, it was always difficult for me to create custom styles. Therefore, when I decided to tackle styles on my own blog, I decided to use Tailwindcss. Tailwindcss is a CSS framework that allows you to create custom styles using only HTML classes. It provides a set of classes that can be used to create custom styles.

In this post, I will tell you how I used Tailwindcss to style my website and blog.

In order for the website to be accessible on the internet, it makes sense to publish it on some hosting platform. Such hosting platforms can be Netlify, GitHub Pages, GitLab Pages, Amazon S3, Google Cloud Storage, Firebase Hosting, Surge.sh, Aerobatic, CloudCannon, Neocities, GitBook, Heroku, Rackspace, OpenShift, CloudFront, Fastly, and others.

I decided to publish my website on GitHub Pages because it is free and convenient. Besides, since I already use GitHub to store and manage the source code of my website, it would be a logical choice. In this article, I will explain what needs to be done to publish a website on GitHub Pages using GitHub Actions.