A. Rothuis

I have been using Docker for a lot of things. For example, docker-compose is extremely useful for quickly setting up a service-based development environment.

Recently, I had the need to run a command once in a Docker image and do something with the file output. For instance, this is quite useful when encapsulating a compilation step or when processing data from one file to another using a docker image, so a user only needs docker as a dependency and the image does the rest.

In this short post, we will explore using files in one-off docker commands with and without defining a custom Dockerfile.

Nowadays, it is important to offer a secure connection through your website via HTTPS and TLS/SSL. Getting a certificate used to be costly and difficult. Luckily, Let’s Encrypt offers a free and relatively simple way of setting up HTTPS for a certain domain.

Certificates from Let’s Encrypt are valid for 90 days. This means that we have to manually renew our certificate and update our site. At the time of writing, GitLab.com does not have a way of automatically renewing certificates for GitLab pages that use their own domain name.

In this post, we will configure Let’s Encrypt for our GitLab pages site, under a custom domain, but hosted on GitLab.com. We will automate the process using GitLab CI, Personal Access Tokens and gitlab-le.

As a lecturer at the Hogeschool Utrecht, I teach Python to students who are mostly new to programming. Having recently restarted my attempts to learn Haskell, I can relate to students’ feelings of being lost or overwhelmed. It takes me back to when I first started writing code. Not only does it give me the joy of learning something new, the process gives me insight in the things we take for granted when talking about code and learning a language: syntax, problem decomposition, patterns and approaches.

In this post, we explore the similarities and differences in imperative and functional approaches to accumulating values over a sequence using Python and Haskell.

In a previous post, we have seen messaging primitives: events, commands and queries. In this post, we will take an extensive look at publish-subscribe: a common messaging pattern for decoupled and (near-)realtime communication.

It is no secret the software industry has issues regarding diversity and inclusivity. The use of language can play a role in creating an atmosphere that is welcoming to everyone – or, at the very least, not uninviting.

For the purpose of shaping a welcoming community through language and not alienating anyone, it is necessary to be mindful (or reminded) of sensitivities, especially of those not felt by the author or voiced by the people in the author’s bubble.

Alex is a tool that can help with this.

Messaging is a way of communicating between systems, services or components. Message-driven architectures, especially event-driven architectures, are on the rise thanks to service-based approaches to software architecture such as microservices.

In this post, an overview will be offered of the primitives used in messaging: messages. Furthermore, Data Transfer Objects as a way of implementating messages are discussed. Finally, it is proposed that Data Transfer Objects can be used to reflect the use cases of an application.

Sometimes, operations need to be run upon booting a Docker container,for instance when creating, configuring or pre-seeding a database. In this post, we will see how to run CQL when starting a Scylla Docker container.

In line with the Agile manifesto, working software is to be favored over comprehensive documentation. Even though keeping an up-to-date documentation can cost a lot of time and effort, this does not mean it should be disregarded entirely. In fact, it is possible to embed documentation in the agile development process, while working towards a shared understanding and common language of the business domain.

Principles of Behaviour Driven Development and Specification By Example can help in maintaining an ever-evolving body of (executable) documentation for the application. Let’s explore these ideas by writing user stories and setting up end-to-end tests for a live web application using Cucumber, nightmare and chai.