Geek Reads are a selection of the articles, tools and announcements I have found interesting while browsing the interwebs, I save all of these in my pinboard account and gather them up periodically and post them here.
A wide range of kotlin tutorials
A beginner friendly introduction to prometheus
Whether you’ve been wanting to learn about GitOps for the first time or you need help to convince your teams to understand the benefits of GitOps, this event is for you! The even has now passed, but you should definitely take a look at the videos on youtube.
There’s no dearth of information or best-practices or books about how best to test software. This post, however, focuses solely on testing backend services and not desktop software or safety critical systems or GUI tools or frontend applications and what have you.
Code reviews are essential, but they are not always done correctly. This article points out, and rants about, particular antipatterns all developers have probably experienced while their code is reviewed or when they submit pull requests.
In the microservice world, we have services talking to each other. One method of communication is synchronous. However, in the cloud computing world, the fact is that we cannot avoid network glitches, temporary service downtime (due to a restart or crash; not more than a few seconds). When clients need real-time data and your downstream service is not responding momentarily, it may impact the users, so you should create a retry mechanism. There are many solution options available in Java. I am going to talk about Spring Retry in this blog. We will build a small application and see how Spring Retry works.
Many people who work in software development today have heard of the practice of pair programming, yet it still only has patchy adoption in the industry. One reason for its varying acceptance is that its benefits are not immediately obvious, it pays off more in the medium- and long-term. And it’s also not as simple as “two people working at a single computer”, so many dismiss it quickly when it feels uncomfortable. However, in our experience, pair programming is vital for collaborative teamwork and high quality software.
Threads are heavy-weight and have substance. With threads, we can get a reference to some kind of current Thread object, examine its properties, modify its thread-local variables, and otherwise manipulate it. It is no surprise that people with the thread-programming background and education, who are coming to programming with coroutines, are looking for some kind of Coroutine object they can get hold of. However, there is none. Coroutines are phantom, ephemeral, insubstantial. There are good reasons for this state of affairs and some non-trivial consequences.
Coroutines are officially part of the Kotlin standard library starting with version 1.3 and they are very helpful in creating concurrent non-blocking code. They simplify async programming. Coroutines are actually lightweight threads.
Kotlin provides us a lot of handy utilities, like takeIf etc. It can help make code so much concise, removed temporary variable, etc. Using Kotlin takeIf (or takeUnless). However, if we get too much into it, it complicates the readability of the code.
As with any new technology, Microservices have followed the inevitable Gartner hype curve. From what we are gathering in the twitter-verse, it’s somewhere between the depths of the trough of disillusionment or starting the climb up the early part of the slope of enlightenment. That means that over the last six or so years, we’ve learned some important lessons about building Microservices, and one of those lessons has to do with making sure that you think about the scope of each microservice in the proper way.
In this new video course, I’ll show some further tips and tricks and aim to give some inspiration about what you can do as a developer to be more productive using your keyboard. Some of the tools and technology I’m using is surely opinionated, however, this course aims to demonstrate the concepts and ideas rather than just single, fixed implementations.
In this course, you will learn the Kotlin programming language from the ground up.
You have consistently written unit tests and you have a line coverage of, let us say, 80% and all of your tests pass. Pretty good, isn’t it? But then you change your code and still all of your tests pass although you have changed code which is covered by your unit tests. In this post, we will take a look at mutation testing which will test the quality of your unit tests.
This post includes a simple example to show why mocking frameworks are important and where they are useful.
SpringOne is going virtual
The same cloud native conference you know and love, in an all-virtual format. See your old pals and make new ones. Watch hundreds of breakout sessions. And catch your favorite speakers, all from the comfort of your living room or repurposed kitchen nook (and likely theirs).
It’s all online. It’s all free. It’s all (still) happening.
Live coding music library/environment for Kotlin
KubeAcademy courses are composed of a series of bite-size video lessons developed by expert instructors.