<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>SebWalak.com</title>
    <link>https://blog.sebwalak.com/</link>
    <description>Recent content on SebWalak.com</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <lastBuildDate>Tue, 06 Aug 2024 00:00:00 +0000</lastBuildDate><atom:link href="https://blog.sebwalak.com/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Java Module System</title>
      <link>https://blog.sebwalak.com/post/java-features/java-module-system/</link>
      <pubDate>Tue, 06 Aug 2024 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/java-features/java-module-system/</guid>
      <description>
        
          
            Ever since I came across release notes of Java 9 (released in September 2017) I was telling myself to look at the JPMS one day.
It was a product of project Jigsaw. Quote from that site
The primary goals of this Project were to:
Make it easier for developers to construct and maintain libraries and large applications; Improve the security and maintainability of Java SE Platform Implementations in general, and the JDK in particular; Enable improved application performance; and Enable the Java SE Platform, and the JDK, to scale down for use in small computing devices and dense cloud deployments.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Blog anatomy - Infrastructure provisioning (upgrade 2024)</title>
      <link>https://blog.sebwalak.com/post/blog-anatomy/7/</link>
      <pubDate>Thu, 11 Jul 2024 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/blog-anatomy/7/</guid>
      <description>
        
          
            I expected that the provisioning aspect will swallow a lion&#39;s share of my time devoted to upgrade.
I knew that the iterations that help my discovery process and testing are going to be really slow when run on certain cloud services. That&#39;s in contrast to superfast iterations when executing code locally:
CloudFront takes time updating distribution at edge locations. I’m really pleased AWS allowed CloudFront functions in-place of Lambda@Edge as the latter was ridiculously slow to propagate.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Blog anatomy - Infrastructure provisioning overview</title>
      <link>https://blog.sebwalak.com/post/blog-anatomy/6/</link>
      <pubDate>Mon, 08 Jul 2024 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/blog-anatomy/6/</guid>
      <description>
        
          
            CDK is an interface between you and CloudFormation Simply speaking, CDK is just a CloudFormation generator, but wait ... that&#39;s a good thing.
CloudFormation is powerful, just not pleasant to use, in my opinion. I find CloudFormation hard to read, long-winded, non-extendable, arbitrarily structured, and I dislike the verbosity when using functions, especially when chaining them.
I haven&#39;t worked in IDE that would support (read as &amp;quot;support well&amp;quot;) crafting CloudFormation. That gets even more important as your CloudFormation template repository grows and you’re trying to perform reliable refactoring, reference search, etc.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Blog anatomy - Cloud services</title>
      <link>https://blog.sebwalak.com/post/blog-anatomy/5/</link>
      <pubDate>Fri, 05 Jul 2024 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/blog-anatomy/5/</guid>
      <description>
        
          
            The following sections will highlight the Cloud Service architecture and management approach behind this site.
Please note: If you are not familiar with term Pet/Cattle infrastructure management style, please have a look at my previous post in this series
Pet resources &amp;#x1f97a; When I was first creating this site, I created the services via the UI.
It was particularly helpful for learning about AWS CloudFront and AWS Lambda@Edge (as opposed to plain AWS Lambda).
          
          
        
      </description>
    </item>
    
    <item>
      <title>Blog anatomy - Managing cloud resources</title>
      <link>https://blog.sebwalak.com/post/blog-anatomy/4/</link>
      <pubDate>Tue, 02 Jul 2024 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/blog-anatomy/4/</guid>
      <description>
        
          
            Pets or cattle This analogy highlights the different approach we take when managing resources.
Pets approach as equivalent of long-lived, manually managed resources With pets, we care about their name, we tend to them regularly, and they get that special spot in our life. More importantly, we want them to live long, their loss will hurt and they&#39;re challenging to replace.
This is the equivalent of manually managed, long-lived resources that you don&#39;t want to rebuild because it may be:
          
          
        
      </description>
    </item>
    
    <item>
      <title>Blog anatomy - Site generation (upgrade 2024)</title>
      <link>https://blog.sebwalak.com/post/blog-anatomy/3/</link>
      <pubDate>Fri, 28 Jun 2024 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/blog-anatomy/3/</guid>
      <description>
        
          
            I updated Hugo from 0.88.0 to 0.127.0 which, trusting semantic versioning, was going to be backward compatible. That update bundled 3 years of change within Hugo and the theme. I mentioned the theme as it is one of the main reasons the site looks and works the way it does. Albeit the theme provided most of the features I wanted already, I&#39;ve customized quite a few behaviours so that only created more chance of incompatibility.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Blog anatomy - Site generation overview</title>
      <link>https://blog.sebwalak.com/post/blog-anatomy/2/</link>
      <pubDate>Sat, 22 Jun 2024 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/blog-anatomy/2/</guid>
      <description>
        
          
            I ported this blog from Jekyll to Hugo in 2021. Both are classed as static site generators 1.
It was triggered after Jekyll reached version 4, which I wanted to roll with, but I got stuck on an upgrade.
I started having issues with generating, and, it didn&#39;t seem like there&#39;s an obvious solution to it (at least at the time). I ended up browsing the Web for a while but had no luck.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Blog anatomy</title>
      <link>https://blog.sebwalak.com/post/blog-anatomy/1/</link>
      <pubDate>Thu, 20 Jun 2024 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/blog-anatomy/1/</guid>
      <description>
        
          
            Introduction Surprisingly, to-date, I wrote little about the technologies behind this blog or about the tech journey it went on. Recently, I decided to improve the process behind it and update the tech stack as it aged. As I was already in that mental context, I wanted to share it and document some findings that may be useful to you.
Knowing it is a static site, you might be wondering what is the big deal?
          
          
        
      </description>
    </item>
    
    <item>
      <title>Demo user with AWS-CLI and MFA. </title>
      <link>https://blog.sebwalak.com/post/demo-aws-cli-mfa-iam/</link>
      <pubDate>Sun, 28 Oct 2018 12:00:00 +0100</pubDate>
      
      <guid>https://blog.sebwalak.com/post/demo-aws-cli-mfa-iam/</guid>
      <description>
        
          
            Why? I was preparing to a demo of AWS features and I was going to use CLI for most AWS interactions. Presented material was spanning across multiple services and involved creation and destruction of resources that incur cost. Some of the actions required a user that is empowered. The broad range of services required a versatile one. Who knows what you may need during a live demo?
For AWS-CLI interactions I used to create an IAM user (at least didn&#39;t use root) and invoke aws configure.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Car Battery Discharge Guard</title>
      <link>https://blog.sebwalak.com/post/battery-discharge-guard/</link>
      <pubDate>Sun, 21 Oct 2018 17:00:00 +0100</pubDate>
      
      <guid>https://blog.sebwalak.com/post/battery-discharge-guard/</guid>
      <description>
        
          
            Use case While the standard car battery is discharged, its plates undergo sulfation. This process is reversed during charging unless the battery has been severly depleted one or more times. In this case you may not be able reach the full charge level.
I use electronic equipment which is connected to a car&#39;s lighter socket for an extended period of time. Think along the lines of a dash cam, car tracker, mobile phone or tablet, fridge etc.
          
          
        
      </description>
    </item>
    
    <item>
      <title>AWS AMI Snapshotter</title>
      <link>https://blog.sebwalak.com/post/aws-ami-snapshot/</link>
      <pubDate>Sun, 14 Oct 2018 21:30:00 +0100</pubDate>
      
      <guid>https://blog.sebwalak.com/post/aws-ami-snapshot/</guid>
      <description>
        
          
            What is it? This terraform project will execute given script on AWS EC2 (installation here) and take AMI snapshot of it so that future EC2 can be spun up from that AMI, without the burden of running initial installation. Terraform destroy subcommand will purposefully NOT destroy the AMI, but will destroy the original EC2 and associated resources.
Code available on BitBucket.
Why? Lately I have been provisioning a number of instances which required a significantly large package to be downloaded and installed on them.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Dockerised DropWizard</title>
      <link>https://blog.sebwalak.com/post/dockerised-dropwizard/</link>
      <pubDate>Thu, 09 Aug 2018 18:01:10 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/dockerised-dropwizard/</guid>
      <description>
        
          
            What is it? It started as an exercise that was supposed to satisfy few, artificial requirements for a technical interview.
I have never attended the interview but most of the solution was ready and I thought I will keep going to learn new and solidify existing knowledge.
It incorporates few techniques and technologies and should be useful reference for projects using:
Maven to orchestrate the following: build code unit test package build Docker images execute integration tests against Docker container execute e2e tests against all containers (just a demo) push Docker images to registry
          
          
        
      </description>
    </item>
    
    <item>
      <title>Fnatic Gear Rush Mechanical Keyboard</title>
      <link>https://blog.sebwalak.com/post/fnatic-gear-rush-keyboard-failure/</link>
      <pubDate>Wed, 20 Jun 2018 10:00:00 +0100</pubDate>
      
      <guid>https://blog.sebwalak.com/post/fnatic-gear-rush-keyboard-failure/</guid>
      <description>
        
          
            The goods I am referring here to product named &amp;quot;Rush Pro Gaming Keyboard, Brown MX Cherry Switches, UK layout&amp;quot;.
It is quite a heavy keyboard that makes impression of well made. It is looking very minimalistic, compared to other mechanical keyboards. I love the double port usb hub included in the keyboard itself. I am happy with the dimmable key illumination, albeit in just one color - red. Wrist support also comes in handy.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Simple WordPress shortcode plugin running MySQL queries</title>
      <link>https://blog.sebwalak.com/post/wordpress-shortcode-plugin-sql-query/</link>
      <pubDate>Thu, 03 May 2018 18:01:10 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/wordpress-shortcode-plugin-sql-query/</guid>
      <description>
        
          
            I&#39;ve recently been asked for advice regarding developing a simple WordPress plugin that can perform explicit interactions with the database.
Having no prior experience of WordPress and very short experience of PHP (and this is dating 20 years back) I had no idea how one would tackle it. I was tempted to just say no, especially that PHP is one of the technologies I just can&#39;t produce a spark of love towards.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Metronome&#39;s Cacophony (14/14) - concurrency in Go  - Appendices</title>
      <link>https://blog.sebwalak.com/post/metronome-cacophony/14/</link>
      <pubDate>Tue, 01 May 2018 11:02:10 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/metronome-cacophony/14/</guid>
      <description>
        
          
            Appendices A. Concept of volumeMeter All scenarios are using a mysterious variable volumeMeter. It allows me to emulate lag of volume measurement in controlled fashion
Note: You don&#39;t need to study the contents of volumeMeter as long as you assume that it is a function that provides current volume and is designed to simulate short- and long-running tasks in controlled manner.
For all of the examples in this series volumeMeter is a provider function created with:
          
          
        
      </description>
    </item>
    
    <item>
      <title>Metronome&#39;s Cacophony (13/14) - concurrency in Go  - Video and Final Word</title>
      <link>https://blog.sebwalak.com/post/metronome-cacophony/13/</link>
      <pubDate>Tue, 01 May 2018 11:02:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/metronome-cacophony/13/</guid>
      <description>
        
          
            Asynchronous approach (ctd) Channels (ctd) Bonus contents ;) Intro Sorry for awful sound experience in this part (cutouts, crackling and volume deviations).
Subsequent parts went better and suffer mainly from my poor diction and stutter.
Your browser does not support the video tag. Counting Service Your browser does not support the video tag. Timing Service Your browser does not support the video tag. Volume Measuring Service Your browser does not support the video tag.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Metronome&#39;s Cacophony (12/14) - concurrency in Go  - Solution with Channel</title>
      <link>https://blog.sebwalak.com/post/metronome-cacophony/12/</link>
      <pubDate>Tue, 01 May 2018 11:01:50 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/metronome-cacophony/12/</guid>
      <description>
        
          
            Asynchronous approach (ctd) Channels (ctd) Solution with channels and a Goroutine This solution uses Goroutine to measure volume upon request, and a request and response channels to communicate between Goroutine and main loop. In practise, the volume measurement is continuous, because request for volume is sent as soon as volume (response) is received.
1func(bpm param.Bpm, performer metronome.BeatPerformer) { 2 3 // channel will carry requests for volume from main loop to the volume measuring Goroutine 4 // I had to add buffer of one as, straight from start, I need to send two requests without 5 // receiver attached (which would block) 6 volumeRequestsChannel := make(chan bool, 1) 7 8 // channel will deliver volume measurements from volume measuring Goroutine to the main loop 9 // no need for buffering as main loop will swiftly receive all messages 10 volumeResponsesChannel := make(chan int) 11 12 // Goroutine which drains volume requests channel, measures 13 // volume on each request, then sends the volume 14 // in response message 15 go func() { 16 for range volumeRequestsChannel { 17 // request arrived 18 19 // blocking volume measurement (but does not impact main timing 20 // loop as this operation runs in Goroutine) 21 volume := volumeMeter() 22 23 // send the latest measurement as response 24 volumeResponsesChannel &amp;lt;- volume 25 } 26 // at this point we know that volume requests channel 27 // is closed and empty (because for-range loop ended) 28 29 // close volume response channel to indicate this Goroutine is ending 30 close(volumeResponsesChannel) 31 }() 32 33 // request first volume measurement, so that we know when to start the timer 34 volumeRequestsChannel &amp;lt;- true 35 36 // request next volume measurement 37 volumeRequestsChannel &amp;lt;- true 38 39 // once we get the first volume measurement the timer can start 40 // without this the time span between the first two beats (only) 41 // would likely be longer than desired interval 42 volume := &amp;lt;-volumeResponsesChannel 43 44 // starting timer right after first volume arrived ensures that the next timing event 45 // will have at least this volume to work with (otherwise it would have to wait for some volume or default it) 46 ticker := time.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Metronome&#39;s Cacophony (11/14) - concurrency in Go  - Goroutines and channels</title>
      <link>https://blog.sebwalak.com/post/metronome-cacophony/11/</link>
      <pubDate>Tue, 01 May 2018 11:01:40 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/metronome-cacophony/11/</guid>
      <description>
        
          
            Asynchronous approach (ctd) Channels (ctd) Channel and Goroutine None of the previous examples demonstrated channels in the environment where they make most sense - concurrent one. My intention was to keep the examples as simple as possible and, at the same time, demonstrate the use of channels in synchronous way. What you have learned so far about channels will apply to Goroutines, so you didn&#39;t waste time by learning about it.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Metronome&#39;s Cacophony (10/14) - concurrency in Go  - Channel select</title>
      <link>https://blog.sebwalak.com/post/metronome-cacophony/10/</link>
      <pubDate>Tue, 01 May 2018 11:01:30 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/metronome-cacophony/10/</guid>
      <description>
        
          
            Asynchronous approach (ctd) Channels (ctd) Select statement If you want to embrace Go&#39;s channels, but are feeling constrained by all the blocking operations on them, select will make your day. It is part of Go&#39;s syntax and - in its simplicity - it&#39;s stunning how powerful it is. Link to documentation.
Non-blocking channel receive with select statement 1package main 2 3import &amp;#34;fmt&amp;#34; 4 5func main() { 6 words := make(chan string) 7 select { 8 case word := &amp;lt;-words: 9 fmt.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Metronome&#39;s Cacophony (9/14) - concurrency in Go  - Channels introduction</title>
      <link>https://blog.sebwalak.com/post/metronome-cacophony/9/</link>
      <pubDate>Tue, 01 May 2018 11:01:20 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/metronome-cacophony/9/</guid>
      <description>
        
          
            Asynchronous approach (ctd) Channels Channels are extremely important in Go. They require shift of concurrent system design paradigm but they also ease you into it. I&#39;m not going to scrimp on space to introduce them.
What are channels in Go?
Channels are the pipes that connect concurrent goroutines.
You can send values into channels from one goroutine and receive those values into another goroutine.
-- gobyexample.com
Speaking of their properties and usage, channels are FIFO constructs.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Metronome&#39;s Cacophony (8/14) - concurrency in Go  - Mutex</title>
      <link>https://blog.sebwalak.com/post/metronome-cacophony/8/</link>
      <pubDate>Tue, 01 May 2018 11:01:10 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/metronome-cacophony/8/</guid>
      <description>
        
          
            Asynchronous approach (ctd) Mutex Term stands for mutual exclusion. In programming it is a property limiting resource access to one thread (or even one consumer - due to lack of reentrancy, later about that) at a time. Sounds familiar? In previous section the atomic functions were helping us achieve just that in context of simple variables.
Atomic functions allow you to write, read or compare variables values in a mutually exclusive fashion.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Metronome&#39;s Cacophony (7/14) - concurrency in Go  - Atomicity</title>
      <link>https://blog.sebwalak.com/post/metronome-cacophony/7/</link>
      <pubDate>Tue, 01 May 2018 11:01:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/metronome-cacophony/7/</guid>
      <description>
        
          
            Asynchronous approach (ctd) Atomic Go provides you with sync/atomic package to help you with sharing state correctly. The tools within that package will help us provide implementation of metronome&#39;s engine with much more reliable performance.
Let&#39;s start with generic definition of atomicity
atomicity
/ˌatəˈmɪsɪti/
noun
[...] the state or fact of being composed of indivisible units. -- by Google
In context of task execution, atomicity is a property that means task has no apparent effect until it completes in its entirety.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Metronome&#39;s Cacophony (6/14) - concurrency in Go  - Sharing state</title>
      <link>https://blog.sebwalak.com/post/metronome-cacophony/6/</link>
      <pubDate>Tue, 01 May 2018 11:00:50 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/metronome-cacophony/6/</guid>
      <description>
        
          
            Asynchronous approach (ctd) Sharing access to mutable state Our solutions utilising Goroutines purposefully didn&#39;t share much state between Goroutines. I didn&#39;t want to pile it on you straight from start. A little exception was a solution with WaitGroup which allowed us to synchronise the completion of all Goroutines with the program termination, but that was easy because we&#39;ve used proper tool for the job.
Based on previous posts&#39; conclusion, we now want to share the volume value between a Goroutine and main timing loop.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Metronome&#39;s Cacophony (5/14) - concurrency in Go  - WaitGroup</title>
      <link>https://blog.sebwalak.com/post/metronome-cacophony/5/</link>
      <pubDate>Tue, 01 May 2018 11:00:40 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/metronome-cacophony/5/</guid>
      <description>
        
          
            Asynchronous approach (ctd) WaitGroup Most asynchronous activities need a mechanism to signal completion with the option to deliver its outcome. We do this so that we can gather results of these Goroutines or just to to proceed once their effect sets, including graceful application termination scenario.
Note: I am saying most and not all, because we also have &amp;quot;fire and forget&amp;quot; model where we are not bothered about this signal, or the outcome, at least not in an immediate time-frame (I would put UDP here as an example).
          
          
        
      </description>
    </item>
    
    <item>
      <title>Metronome&#39;s Cacophony (4/14) - concurrency in Go  - Goroutine</title>
      <link>https://blog.sebwalak.com/post/metronome-cacophony/4/</link>
      <pubDate>Tue, 01 May 2018 11:00:30 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/metronome-cacophony/4/</guid>
      <description>
        
          
            Asynchronous approach Another big word, another definition
asynchronous
/eɪˈsɪŋkrənəs/
adjective
not existing or occurring at the same time. COMPUTING, TELECOMMUNICATIONS
controlling the timing of operations by the use of pulses sent when the previous operation is completed rather than at regular intervals. -- by Google
In the context of programming models, I will translate it as &amp;quot;disconnected&amp;quot;. It means that in case of two asynchronous tasks processing of any of them can start before the other has finished.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Metronome&#39;s Cacophony (3/14) - concurrency in Go - Ticker</title>
      <link>https://blog.sebwalak.com/post/metronome-cacophony/3/</link>
      <pubDate>Tue, 01 May 2018 11:00:20 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/metronome-cacophony/3/</guid>
      <description>
        
          
            Synchronous approach (ctd) Ticker Ticker is a very convenient tool used to schedule tasks to happen at regular interval. It is created with an invocation of time.NewTicker and needs a time.Duration parameter. It will create a channel, which will be receiving time.Time messages at intervals equal this duration. Ticker channel is available at ticker.C.
Simple example:
1package main 2 3import ( 4 &amp;#34;time&amp;#34; 5 &amp;#34;fmt&amp;#34; 6) 7 8func main() { 9 // make note of the time program started (so we can stop it after elapsed time 10 start := time.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Metronome&#39;s Cacophony (2/14) - concurrency in Go - Basic synchronous solution</title>
      <link>https://blog.sebwalak.com/post/metronome-cacophony/2/</link>
      <pubDate>Tue, 01 May 2018 11:00:10 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/metronome-cacophony/2/</guid>
      <description>
        
          
            Synchronous approach Before we move on I will try to explain what the big word is
synchronous
/ˈsɪŋkrənəs/
adjective
existing or occurring at the same time. &amp;quot;glaciations were approximately synchronous in both hemispheres&amp;quot;
-- by Google
Did it help? Did it resonate with you?
Well, for me it felt like the definition contradicts my understanding of the term in context of software development.
By the looks of it, many people are in the same boat, just look at this StackOverflow debate.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Metronome&#39;s Cacophony. Concurrency in Go.</title>
      <link>https://blog.sebwalak.com/post/metronome-cacophony/1/</link>
      <pubDate>Tue, 01 May 2018 11:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/metronome-cacophony/1/</guid>
      <description>
        
          
            Introduction The times of PCs with a single-core CPU seem to be gone. Single-core processors still appear in special use cases but, in Personal Computing, they are pretty much extinct. We exhibit constant drive for bigger, faster and richer. If I was buying a new PC, I wouldn&#39;t consider single-core CPU, unless it was clocked at extraordinarily high frequency.
At this moment however, we can&#39;t get our CPUs to be clocked at much faster speeds due to a number of factors, power wall being one and speed constraints at a sub-component level being another.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Jekyll&#39;s Docker image</title>
      <link>https://blog.sebwalak.com/post/jekyll-docker-image/</link>
      <pubDate>Wed, 04 Apr 2018 02:53:00 +0100</pubDate>
      
      <guid>https://blog.sebwalak.com/post/jekyll-docker-image/</guid>
      <description>
        
          
            Jekyll&#39;s ecosystem I was pretty excited when I found out about Jekyll about a month ago.
It not only gives me the most of the content authoring functionality I need, it also allows me to gain nearly complete control over the site&#39;s features and aesthetics. If I knew Ruby, or if the plugins did exactly what I need, I would probably have to say &amp;quot;...gain total control&amp;quot;.
The platform is extendable by means of Ruby plugins.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Maplin goes into administration - will I miss it?</title>
      <link>https://blog.sebwalak.com/post/maplin-goes-into-administration-will-i-miss-it/</link>
      <pubDate>Wed, 28 Feb 2018 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/maplin-goes-into-administration-will-i-miss-it/</guid>
      <description>
        
          
            Maplin goes into administration Today it was announced that Maplin, the only high-street electronics chain that I know of, went into administration (BBC).
I have mixed feelings about this retailer.
I am into electronics and tinkering. I like to see what I&#39;m buying compared to looking at a picture only. I definitely value an option to be able to pick up immediately, especially if your project grinds to a halt because you&#39;ve burnt your last ATmega328.
          
          
        
      </description>
    </item>
    
    <item>
      <title>The beast from the east</title>
      <link>https://blog.sebwalak.com/post/the-beast-from-the-east/</link>
      <pubDate>Wed, 28 Feb 2018 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/the-beast-from-the-east/</guid>
      <description>
        
          
            While I was clearing snow off my car today, at the point I got to the radio antenna I was thinking about the need for simple radio receivers in the modern world. For a piece of electronic gadgetry that is well over 100 years old it is unbelievable that modern cars are still equipped with one. In the era of insane consumption, hunger for more processing power, built-in obsolescence and cheap materials, nothing seems to last longer than few years.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Filesystem impact testing</title>
      <link>https://blog.sebwalak.com/post/go-filesystem-testing-filefactory/</link>
      <pubDate>Mon, 26 Feb 2018 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/go-filesystem-testing-filefactory/</guid>
      <description>
        
          
            FileFactory Repo is located on BitBucket.
What is it? Provides declarative means to describe (define) filesystem primitives such as Regular files, Directories and Symlinks. These definitions will be used to create real files and verify that real files exists as per specification. Hence the &amp;quot;factory&amp;quot; analogy.
Why? I have been developing some filesystem utilities and found that testing of their intended and side effects to the filesystem was time consuming, repetitive and the tests were too verbose for my liking.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Operating on time ranges</title>
      <link>https://blog.sebwalak.com/post/basic-operations-on-time-ranges-go-library/</link>
      <pubDate>Wed, 29 Nov 2017 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/basic-operations-on-time-ranges-go-library/</guid>
      <description>
        
          
            For one of my recent projects I needed a tool to perform few basic operations on time ranges (called periods here).
I was doing a lot of time manipulation (however cool that sound I am not building a time machine) and was getting tired of polluting other code with this responsibility. I decided to encapsulate that in a separate library.
The library https://bitbucket.org/outo/temporal/src/master/pops/ (period operations) contains:
Contains constructs:
Period: an immutable representation of time range with the lower boundary being inclusive and upper being exclusive
          
          
        
      </description>
    </item>
    
    <item>
      <title>Base, custom VPC stack, provisioned with Terraform in AWS</title>
      <link>https://blog.sebwalak.com/post/base-aws-stack-provisioned-with-terraform/</link>
      <pubDate>Thu, 23 Nov 2017 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/base-aws-stack-provisioned-with-terraform/</guid>
      <description>
        
          
            This post shows Terraform configuration files I have used to create base AWS stack for my projects. It is a minimal configuration for new VPC with public/private subnets and autoscaling bastion.
Following is my best attempt at illustrating it.
The stack consists of var.az_count (declared in variables.tf) subnets with route via NAT (here referred to as private) and equal number of subnets with route via Internet Gateway (aka public). The maximum value of var.
          
          
        
      </description>
    </item>
    
    <item>
      <title>AppScript - How to automatically groom Gmail account?</title>
      <link>https://blog.sebwalak.com/post/app-script-gmail-auto-grooming/</link>
      <pubDate>Wed, 22 Nov 2017 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/app-script-gmail-auto-grooming/</guid>
      <description>
        
          
            This post shows my example implementation of auto-delete solution that will traverse my Gmail account in search of qualifying messages and remove them.
If you have ever owned some of the cheap CCTV cameras you might have chosen to automatically send motion snapshots and alerts to your email address. It can work but can overload your email account very quickly. Some people will say that I haven&#39;t used the right tool for the job and I completely agree with them.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Non-blocking lighting effects in Arduino</title>
      <link>https://blog.sebwalak.com/post/non-blocking-lighting-effects-in-arduino/</link>
      <pubDate>Sun, 19 Nov 2017 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/non-blocking-lighting-effects-in-arduino/</guid>
      <description>
        
          
            There&#39;s been some occasions when I needed to perform few operations on an Arduino/Genuino board, but these had to happen along each other. This platform does not support parallel execution, and there isn&#39;t any built-in higher level tools to support asynchronous execution, but you can emulate asynchronous execution by changing the composition of your code.
In this particular case my requirements for the product were:
The lighting is to be following some predefined, sometimes elaborate patterns of intensities depending on elapsed time The product would react to user interactions via a number of buttons and a potentiometer Some of the problems requiring non-blocking processing can be tackled with interrupts but the number of pins providing this feature is limited on the traditional boards (Uno, Nano, Mega, Micro and others).
          
          
        
      </description>
    </item>
    
    <item>
      <title>Peek at Ginkgo and Gomega - BDD in Go</title>
      <link>https://blog.sebwalak.com/post/ginkgo-and-gomega-bdd-approach-in-go/</link>
      <pubDate>Fri, 17 Nov 2017 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/ginkgo-and-gomega-bdd-approach-in-go/</guid>
      <description>
        
          
            Ginkgo and Gomega libraries offer enough support to feel mature and help form readable, nicely flowing BDD style, executable requirements.
Ginkgo does not strictly follow Gherkin notation but, since the narrative for tests is a free form text nothing stops you from typing what you want there. You could also create your own functions in place of Describe, Context, It, Specify to make it look like familiar Given, When and Then.
          
          
        
      </description>
    </item>
    
    <item>
      <title>Sorting in Go</title>
      <link>https://blog.sebwalak.com/post/sorting-in-go/</link>
      <pubDate>Fri, 17 Nov 2017 00:00:00 +0000</pubDate>
      
      <guid>https://blog.sebwalak.com/post/sorting-in-go/</guid>
      <description>
        
          
            Sorting can be easily implemented by using Go&#39;s interface sort.Interface declared as
1type Interface interface { 2 Len() int 3 Less(i, j int) bool 4 Swap(i, j int) 5} Here&#39;s an example:
1type timedBoundary struct { 2 time time.Time 3 //other fields 4} 5 6type timedBoundaries []timedBoundary 7 8func (a timedBoundaries) Len() int { return len(a) } 9func (a timedBoundaries) Swap(i, j int) { a[i], a[j] = a[j], a[i] } 10func (a timedBoundaries) Less(i, j int) bool { return a[i].
          
          
        
      </description>
    </item>
    
  </channel>
</rss>
