Archive

In this post I'll outline my thought process behind finding a new career path for myself.

Another CTF write up for a very nice, beginner level CTF on TryHackMe

This is my first CTF write-up and it's about the TryHackMe LazyAdmin CTF

In this second part of our journey to try and understand how async I/O works in Rust, we'll build a simple reactor/executor model.

This is the first blog post in a small series, where we will explore the basics of non-blocking IO in Rust. We'll start by building a minimal HTTP server using epoll

Sometimes you need to generate Excel files. You never WANT to, but sometimes you have to. In this post we'll look at how you can do it with Rust. :)

Data privacy is a basic human right and the current smartphone OS duopoly provides no option for customers to be safe from being exploited. In this post I'll show you a much needed alternative.

In this post we'll look at how to do web authorization using the casbin-rs library within a Rust warp-rs web service.

In this post we will look at how to use RabbitMQ inside of a Rust Web Service

In this post we'll look at the refinery library and at how it can help us create automatic database migrations in a Rust Web Service

I haven't been happy with my Macbook and OS X for a while, so I decided to switch to Linux - this post shows how to run Ubuntu on a Macbook.

In this post we'll look at how a very basic OAuth 1.0a implementation can look like in Rust.

In this post we'll be taking a look at the mockito rust library for mocking HTTP requests in order to write integration tests for a web-service

In this post we'll implement a basic asynchronous job runner, which synchronizes job runs among several instances using Redis.

This post shows my minimal setup for analyzing the logs of this Blog using GoAccess and some unix commands.

In this post we'll look at the rationale behind making this blog as fast and lightweight as it is and why there are no trackers and/or ads present and why they never will be.

In a previous post I showed an example CLI application in rust dealing with HTTP and Git. This post will show how to use the new async/await syntax to improve it.

This post is my take on how I have used teaching as a tool for improving and deepening my own knowledge on several topics.

This post showcases a small CLI tool written in Rust using both synchronous and asynchronous execution flow.

This is the story of a bug hunt featuring Gorilla WebSockets, Go and a confused programmer (me) :)

In a previous post, we created an Actix 0.7 Web App, which was not fully non-blocking. In this post, we'll become fully non-blocking and upgrade the app to Actix 1.0

This is an example configuration of a RabbitMQ cluster running in Kubernetes

These are some of the prometheus alerts which have been useful in my (limited) experience.

As a first little project in Rust I thought I'd do something familiar, so I created a small web application, which we'll check out in this post.

This post shows how to create syntax-highlighted HTML from a markdown source using the chroma Go library.

In order to fetch huge amounts of data in a sane way, it often makes sense to scroll through the data instead of requesting it all at once. In this post, we will create a simple implementation of such a mechanism using Kotlin and Spring Boot 2.

This post will show a simple Go program for deleting old logs on the ELK stack.

This post describes how to create a server in Go, which provides data from Elasticsearch for Prometheus to consume.

This post shows a small example of a Kotlin Webflux application handling WebSockets communication.

GraphQL is a powerful concept and this post will show how to translate an existing REST API to GraphQL using Go

This post shows a small example of reactive web-programming in kotlin using the great new Spring Webflux framework.

In this short example we'll create a cached iCal feed with Go for a fake REST API

Casbin is an authorization library for Go, which supports several access control models. In this post we will take a look at a simple HTTP example featuring basic role-based authorization.

One of Go's big upsides, for me, is its simplicity. This post shows another example of this, implementing a basic HTTP File Up- and Download using just the standard library.

Traversing an AST (Abstract Syntax Tree) is useful for analysing and understanding a code-base, but the real power comes when we are able to manipulate it, which allows us to build tools. This post shows a simple example of how to manipulate the AST in Go.

If ethereum or any other smart-contract platform is ever going to reach mainstream, a mechanism for people without holding cryptocurrency is needed. While there are efforts to achieve this in the future on ethereum, this post shows a workaround using a Go webserver.

The ability for Smart Contracts to call other contracts can be quite useful for several use-cases, which will be described in this post.

Since my transition to being self-employed, I have been working from home. This post outlines some of the learnings I made over the last months in terms of increasing my productivity in a sustainable, healthy way.

Light-Clients are a concept widely regarded as important in the Blockchain community due to their fully decentralized nature. In this post, we'll look at an example of how to integrate the go-ethereum light-client with a React Native app

Smart Contracts and Blockchain remain a hot topic. This post will show how to interact with Ethereum Smart Contracts using Go.

Looking at and interacting with the AST (Abstract Syntax Tree) of a program can be both interesting and useful for automation. In this post, we'll look at an example of how to parse a Go program to an AST and how to analyse it.

Docker has a great new feature in 17.05 called Multi-Stage builds. This post shows a practical example for it using complex Single Page Applications

Last November I decided to start writing this Blog. In order to create it, I wrote a static blog generator in Go, which is described in this post.

This post shows one way to create syntax-highlighted HTML from a markdown source. Using only Go.

BoltDB is a simple and fast key/value store written in pure Go. Storm is a toolkit for BoltDB, which helps us tackle more complex use-cases.

Craft Conf has been one of the best tech conferences I've been to and continues to deliver.

Looking for a simple key/value store for your Go applications? Look no further!

In many modern programming languages, you can create web-apps using only the standard library. How well did Java age in this regard?

In this post, I take a look at how simple it is to do port forwarding with Go's great standard library.

In this post I describe my implementation of delta-uploading for AWS S3 within the static-aws-deploy tool using Go

After having written many tests with several bloated mocking frameworks in different languages, this is an attempt at a very simplistic utility for mocking in Go

Smart Contracts and Blockchain Technology are quite intriguing topics. This post shows an example for a Winner Takes All Crowdfunding contract implemented with Solidity.

Machine Learning is rapidly becoming more and more relevant both within the field of Software Development as well as Society as a whole. This post aims to show how very basic Machine Learning techniques can look in Go

Documentation is important. Everyone knows it. Yet, writing even the most basic documentation often gets pushed back in a project's life cycle in order to 'iterate quickly'. I believe that some kinds of documentation, like API docs, actually tremendously speed up the iteration cycle, especially in a distributed microservice world where multiple people and teams need to work together.

This post describes the process of building a small single-purpose tool in Go for deploying static websites to AWS S3 and Cloudfront.

User Groups or Meetups are a great way to stay in touch with the local tech scene. Organizing such a meetup can also be a very rewarding experience, especially if done right and with a vibrant community to back you up.

The io.Reader and io.Writer interfaces in Go are immensely powerful, yet simple. This post explores how we can use another simple concept to create powerful effects: io.Pipe

One of the best ways to learn how to defend your web application from malicious attacks is to learn how these attacks actually work and how they are executed. In short - to learn how to hack. Meet WebGoat, a project which can help you achieve exactly that.