Foci

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.

Web applications have won the fight against desktop applications. Yet, in some contexts, the latter might be as relevant as the former. This focus lists some GUI frameworks that rely on a local JVM.

If data is the new oil, there are several ways to refine this oil into an usable form. Among them, data streaming has lots of benefits over its competitors. This focus aims to uncover several facets of this moeder approach.

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.

Clojure is a functional dynamically-typed language. While it compiles to bytecode and runs on the Java Virtual Machine, its approach is completely different from Java's: it's related to Lisp. It also transpiles to JavaScript - Clojurescript, and compiles to .NET bytecode. This focus in intended for developers who have a background in Object-Oriented languages and who want to start their Clojure journey.

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.

Ethereum is one of the most popular Blockchain technologies available. Compared to most of them, it allows something very attractive to developers: it's possible to code, and deploy it on Ethereum. This focus follows the same steps I did when starting to develop for Ethereum.

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.

Hibernate is a Java Object-Relational Mapping framework provided by RedHat. While it offers powerful features, it also requires time to be mastered. This focus takes a hard look at some Hibernate capabilities, and how to make the best out of them.