I started reading this book on Software Architecture. I find that the book is well written and well structured, but at the same time I found it lacking with perhaps one of the most fundamental questions. What is Software Architecture?
SPACE and Developer Productivity
I stumbled upon this post that is outlining an updated way of measuring developer productivity. I recommend everyone to go there and read it.
Creating a Build User
It’s become very easy to setup github actions to do you building. At some point you probably want the build system to also publish releases into your
AWS account. Now, the shortcut to do this is to simply have some admin role and create an access key for it that you supply to Github. That’s not very nice from a security perspective though. Following the principle of least needed access, you should rather create a user that has the minimum required permissions instead. Now, how do you do that?
ECR and Lambdas Step Two
Ok, so we’re in the middle of pushing lambda images to ECR in AWS. How do you push your image?
Well, here’s a small script that basically does the job.
ECR and Lambdas Step One
AWS released their tool
Serverless Application Model) it conceptually felt like a step forward. Before this many people had probably used
Serverless to simplify their process of pushing
Lambdas, and now finally
AWS was taking steps of standardizing this. I mean, it makes sense. A
Lambda is at its core something very simple. A small piece of code that you want to run under some conditions. So what’s the work you need to do to get it published?
AWS Doable Style
The AWS framework for
Node has been around for a while, and for such reasons probably have to live with backward compatibility. One of the things that has annoyed me with the API is the usage of callbacks. I mean, that’s all fine, but many people these days problably want to use promises and
async / await instead. Turns out that’s not very difficult.
Builder Pattern in Typescript
For anyone that has been around for a while with programming the refactoring problem that arises when you have classes with many properties that suddenly gets a new one is probably familiar. Suddenly you’ll have multiple unit tests spread around your code that needs a value for this new property that you have added. Many of these tests are probably unrelated to this new property, but you have to add something there anyway.
Sync vs Semaphore
I wanted to see how
Synchronized measure against
Semaphores when it comes to performance. Running the test shows a 4 time higher throughput when using
Synchronized instead of
Semaphores which surprises me. I still don’t know why, it warrants an investigation :). The benchmark can be found here
Setting Up KotlinX For Benchmark
Writing benchmarks for JVM is not necessarily easy. JVM is good at optimizing code, so maybe the code you’re executing won’t be what you think it is. Also, coming from the world of physics it would be ideal if somehow the code that is tested could be separated from the code that is measuring. Now fortunately for us there are tools there to help you.
The Pipeline Pattern
I’ve been fascinated by design patterns for a while. I’ve found that the patterns that are outlined in for example
Heads First Design Patterns in theory seem really nice, but in reality don’t really match the kind of problems that I encounter in my every day corporate coding. I’ve attributed this to the fact that the classic design patterns were developed at a different time, where a different type of applications were developed.