A few months ago I started several blogs about Python, Go, and Rust and some miscellaneous subjects.
Hacking with Python
On the hacking with Python blog I write about different things connected with Python. It can be found here
- Introduction Sometimes when locking data or objects it can be handy to reduce the overhead of acquiring a lock on such objects by first checking whether a lock is really necessary. This typically used in combination with lazy initialization in […]
- Introduction In multi-threaded applications it can be necessary to synchronize properties between objects, or at least be notified of changes on certain properties. This is where the Binding Properties comes in, which is basically a form of the Observer pattern. In this […]
- Introduction The Balking Pattern might not be widely known, but it plays a crucial role in preventing certain actions on objects based on their state. For instance, attempting to read the contents of an unopened file should not be allowed. […]
- Introduction Some time ago I heard about new nascent pythonic language called Mojo which apart from being faster, according to their website much faster, was also safer. This of course piqued my curiosity, and I decided to have a go […]
- Introduction In multithreaded applications, it’s common for one thread to let another know when specific conditions are met, like when data is ready or a time-consuming task is finished. In Python, you can use threads, locks and conditions to achieve […]
- Introduction Sometimes, when your program has a task that takes a lot of time, like working with databases, web services, or complex calculations, you might want to let it happen in the background. This way, your program can keep running […]
Hacking with Go
Hacking with Go was started out of my desire and curiousity about the Go language, which is both easy and quite performant. It can be found here.
- Introduction In the previous installments in this series, we worked on the backend for a simple todolist. Now it is time to have some fun in the frontend by using HTMX. We will also use tailwind css for our styling. […]
- Introduction In the previous post we saw how we setup our database functions using GORM. In order for these functions to be accessible we need an API, and that is we are going to build in this article. Prepare yourself […]
- Introduction In my previous post, we set up the packages for our website. Now it is time to start building. We will start by building an important part of the backend, namely the database functions. If you haven’t done already, […]
- Introduction I have been experimenting with Go for a while now, and I am beginning to like it more and more. Especially the way Go handles concurrency makes code clear, readable, and therefore more secure and maintainable. Go, as I […]
- Introduction There are many ways to handle incoming events. If you need to be able to handle many potential service requests concurrently, the Reactor pattern could be your pattern of choice. The key ingredient of this pattern is a so-called […]
- Introduction In some applications it is handy not to say necessary for the main thread (or a thread) to wait for the completion of several worker threads. Examples of these kinds of problems are: There are probably many other use […]
Hacking with Rust
Rust is a hot new programming language, safe and performant at the same time, so I decided to invest some time in it, and blog about it here.
- Introduction In some situation you have a lot of short-lived tasks which need to be performed concurrently. In many cases the overhead of creating and destroying these threads can inhibit the performance of the program. A solution to that would […]
- Introduction There are many ways to handle incoming events. If you need to be able to handle many potential service requests concurrently, the Reactor pattern could be your pattern of choice. The key ingredient of this pattern is a so-called […]
- Introduction In some applications it is handy not to say necessary for the main thread (or a thread) to wait for the completion of several worker threads. Examples of these kinds of problems are: There are probably many other use […]
- Introduction Sometimes when locking data or objects it can be handy to reduce the overhead of acquiring a lock on such objects by first checking whether a lock is really necessary. This typically used in combination with lazy initialization in […]
- Introduction Sometimes in a multi-threaded program, you need to protect a resource from concurrent access, that is access by multiple threads. One way of doing this, is to implement a Monitor Object. To achieve this, we do the following: Implementation […]
- Introduction Especially in multi-threaded applications it can be necessary to synchronize properties between objects, or at least be notified of changes on certain properties. This is where the Binding Properties comes in, which is basically a form of the Observer […]
The Esox Solutions Blog
On this blog, I blog about all kinds of different things which are not appropiate for any of the previous blogs. It can be found here.
- Introduction The builder pattern is a creational design pattern, i.e. it is a pattern for creating or instantiang objects of classes. We can use it for breaking down the construction […] The post Easy Object Construction: Mastering the Builder Pattern in C# appeared first on Hacking Away.
- Introduction Sometimes, it’s useful to have a collection of pre-initialized objects ready for efficiency. This is especially handy when dealing with resource-intensive tasks, such as creating database connections. In this […] The post Easy Efficiency: Unleashing a Thread-Safe Object Pool in C# appeared first on Hacking Away.
- Introduction The Abstract Factory Pattern organizes the creation of related objects, making it easy to interchange them. In our example, we’ll delve into a simplified implementation in C#. If this […] The post Easy Abstract Factory Pattern Implementation in C# appeared first on Hacking Away.
- Introduction When I started out using .NET development, many years ago, SQL Server was the default database server to be used, and let’s be honest: .NET support for SQL Server […] The post .NET, Postgres and Kubernetes: a match made in heaven? appeared first on Hacking Away.
- Introduction In the first part of this two-part series we built a small web api, backed by a postgres database. Now the time has come to deploy this to a […] The post Deploying a Go web API on Kubernetes, part 2: The Kubernetes part appeared first on Hacking Away.
- Introduction After having done some experiments with the Go programming, I really started to like the language, and decided a bold experiment: build a small web API, backed by a […] The post Deploying a Go web API on Kubernetes, part 1: The API part appeared first on Hacking Away.