Rust is a low-level programming language that can generate native binaries and Web Assembly code. It touts itself as being performant, reliable, and productive. The main idea behind Rust is to avoid as many runtime exceptions as possible, especially those related to memory access. For that reason, it provides an additional "borrow checker" that verifies that memory is used safely and throws errors at compile-time when it's not: this adds a layer of complexity compared to most other languages. This focus is dedicated to understanding more about Rust in general and data ownership in particular.
Exercises in Programming Style is a book based on a pretty simple, but very interesting idea: there is a problem to solve with code - search for the 25 most common words in a text file. But here's a twist: there's a set of constraints that the code needs to conform to, each chapter having a different set of such constraints. Each post in this focus is dedicated to a chapter, and tries to solve the code in Kotlin.
Whether one likes it or not, there's now denying that there's currently a huge trend toward Functional Programming. It started with the Scala language that bridged Object-Oriented Programming and Functional Programming. But there's also the Clojure languages that fully embraces FP. And even since Java 8, features of FP have started to creep in. However, most codebases in so-called OOP languages are imperative. This focus is all about the migration from one type of programmning to another.
The JVM is a fine piece of engineering. Coupled with all Java APIs available, it can do a lot: read Java files, compiles them at runtime, execute them... Most applications do not need all those capabilities. Malicious code could take advantage of that, and do something not wanted in the production environment. This focus lists options to harden the JVM, and make that harder.
Scala and Kotlin are both JVM languages. Scala was incepted earlier, and got some traction thanks to developers interested in Functional Programming on the JVM. Kotlin is more like the cool kid on the block, but has recently seen tremendous success, thanks to both Google and Pivotal supporting it respectively on Android and with the Spring framework. Scala is more powerful and academic, while Kotlin is more pragmatic. This focus aims to compare both languages in specific areas.
Microservices are ubiquitous, or at least they are talked about a lot at conferences. There are a lot of Cloud providers around, promising lower costs and huge Return-Over-Instement. This focus goes through the motion of and deploying the exact same sample application on some widespread Cloud providers.