Source code can then be executed in two ways. Language implementations in general either interpret or compile it. In order to run an interpreted program you need one extra binary: an interpreter. Interpretation is simple: you read source code line by line and execute it. The compilation is much harder. A special program called a _compiler_ reads your source code ahead of time (AOT) and translates it into machine code. After this translation your program is standalone. You don't need a compiler to run it. Only you and your CPU.

Business Process Modelling is a collection of tools for declarative process management. Often a drag-and-drop interface allows business people to design a process in the form of a diagram. Each instance of the process travels through this diagram, executing certain code on each step. Sounds abstract?

Akka is a toolkit for building highly scalable, concurrent applications. It's written in Scala and based on the ideas from Erlang. Its approach to achieve concurrency is quite radical. Rather than mutexes, semaphores and shared memory, Akka uses so-called _actor model_. An actor is a small, stateful object that doesn't expose traditional methods. Instead, actors send and receive asynchronous messages with each other. There is no other way to interact with an actor. If you want an actor to do something or give you some information, message passing is the only way. Send a message, actor will receive it at some point in time, consume it and optionally send a response back.

Imagine I wrote a script that takes your codebase and removes a random line. Fairly simple. Or maybe some more subtle change, like replacing plus with minus operator? Or switching `x` and `y` parameters with each other? OK, so now my script builds your project. Most of the time it will fail the compilation or test phase. But what if the build succeeds? Well, apparently your test suite is not covering some lines? OK, but what if my script only removes or alters lines covered by tests? How is it possible that the build still succeeds? Turns out your tests aren't as good as you think. And I just described mutation testing that discovers that.

When choosing or learning a new programming language, type system should be your first question. How strict is that language when types don't really match? Will there be a conservative, slow and annoying compiler? Or maybe a fast feedback loop, often resulting in crashes at runtime? And also, is the language runtime trusting you know what you are doing, even if you don't? Or maybe it's babysitting you, making it hard to write fast, low-level code? Believe it or not, I just described static, dynamic, weak and strong typing.

Cassandra is an open-source NoSQL database. It's heavily optimized for writes, but also has intriguing read capabilities. Cassandra has near-linear scalability. In terms of CAP theorem it favours availability over consistency . Interestingly, despite NoSQL label, Cassandra tables have strict schema. Also, Cassandra Query Language is similar to SQL.

Typically, more than one developer is working on the same codebase. How do they share their work? The simplest approach is a common Dropbox folder. This has several drawbacks, mainly we risk breaking other's work with our half-done features. So we come up with version control systems. There we only commit code when all changes are done.

MapReduce is a programming model for processing large amounts of data. It works best when you have a relatively simple program, but data is spread across thousands of servers. MapReduce was invented and popularized by Google. I'll talk about MapReduce in general and Hadoop in particular.

HTTP protocol is fundamental to the Internet. It's a simple request-response protocol where the request is initiated by the client, typically a web browser

I find it quite fascinating how many failures in complex systems could be avoided if we simply... tried again. So how so you retry effectively, so that your systems are much more fault-tolerant and less brittle?

Kafka is not a message broker. However, it can be used as such very effectively. Instead, I'd like to think about as a very peculiar database. A database where inserts are insanely fast and sequential reads are preferred and very fast as well. Also, there is very little support for deleting and updating data. In this episode I am focusing on the architecture and internals of Kafka. The best way to understand Kafka is by examining how it works.

Speed of light is not as abstract to us, software engineers, as you might think. If you are deploying to the cloud or if you want to squeeze every bit of performance in your app, speed of light holds you back.

Little's law is an astounding equation that's dead simple, yet it can bring an amazing insight into what your distributed system is capable of.

asm.js and WebAssembly are two technologies used to run native code in the browser with great performance. They can be used to run game engines and complex computation on the client.

Serverless (function as a service) is the fastest and most cost effective way of deploying your code to the cloud. However it suffers the cold start problem and pricing is not always straightforward.

GraphQL is a communication protocol that can be compared to RESTful APIs. Just like REST it uses HTTP, however, it tries to solve some issues with it, namely the lack of schema over- and under-fetching.

Service mesh is used in environments where there are many services talking to each other. The aim of the service matches is to extract cross-cutting concerns like infrastructure and networking code to an independent layer. Service mesh is commonly implemented using an HTTP proxy.

Circuit breaker is a design pattern that prevents cascading failures in distributed systems.

The podcast for developers, testers, and SREs. And their managers. I explain complex and convoluted technologies in a clear and concise way avoiding buzzwords and hype.

In sales, you can hear the acronym ABC: Always Be Closing. Closing means making a deal with a customer. Last decade gave rise to another acronym ABCD: Always Be Collecting Data. We use Google for m...

The idea behind GraphQL is to reduce the number of network round-trips by batching multiple, often unrelated requests, into a single network call. This greatly reduces latency by delivering many pi...

In part I we developed a really simple GraphQL server. That solution has a serious flaw: all fields are loaded eagerly on the backend, even if they weren’t requested by the front-end. We sort of ac...

Superficially, there is no reason GraphQL servers are typically written in Node.js. However callbacked-based languages that don’t block waiting for the result turn out to play really well with Grap...

Abstract Fallbacks in circuit breakers replace failure with some pre-configured response so that the scope of the malfunction is limited and hidden from the end user. However, in real life, a naïv...

Russian translation available: Map.merge () - метод, чтобы управлять всеми остальными I don’t often explain a single method in JDK, but when I do, it’s about Map.merge(). Probably the most versati...

Martin Kleppmann, the author of Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems wrote a wonderful, comprehensive book. I consider this to be...

#       Summary: Stick to whichever library you already have on your CLASSPATH. If you get a choice, Reactor is preferable, RxJ...

Something was bothering me for almost two decades. It was a pen and paper game that I learned when I was around 13. The rules are simple: on an empty 10x10 grid (100 squares in total) you put a num...

Summary Deadlocks are caused by many threads locking the same resources Deadlocks can also occur if thread pool is used inside a task running in that pool Modern libraries like RxJava/React...

Almost a year ago Spring team announced spring-cloud-function umbrella project. It’s basically a Spring’s approach to serverless (I prefer the term function-as-a-service) programming. Function<T...

In the first part we managed to connect to emojitracker.com and consume SSE stream that looks like this: data:{"1F60D":1} data:{"1F3A8":1,"1F48B":1,"1F499":1,"1F602":1,"2764":1} data:{"1F607":1,...

In this article we will learn how to consume infinite SSE (server-sent events) stream with Spring’s WebClient and Project Reactor. WebClient is a new HTTP client in Spring 5, entirely asynchronous ...

The final piece of the puzzle in our series is exposing reactive APIs via RESTful interfaces. Previously we were seeding our Elasticsearch with some sample fake data. Now it’s about time to expose ...

Spring Boot 2 is around the corner. One of the minor changes is the replacement of Dropwizard Metrics with Micrometer. The migration path is fairly straightforward and Micrometer actually provides ...

In the previous article we created a simple indexing code that hammers ElasticSearch with thousands of concurrent requests. The only way to monitor the performance of our system was an old-school l...

In the previous article we created a simple adapter from ElasticSearch’s API to Reactor’s Mono, that looks like this: import reactor.core.publisher.Mono; private Mono<IndexResponse> indexDo...

Spring 5 (and Boot 2, when it arrives in a couple of weeks) is a revolution. Not the “annotations over XML” or “Java classes over annotations” type of revolution. It’s truly a revolutionary framewo...

Simple, effective and safe concurrency was one of the design principles of RxJava. Yet, ironically, it’s probably one of the most misunderstood aspects of this library. Let’s take a simple example:...

Imagine you have a stream that publishes events with unpredictable frequency. Sometimes you can expect dozens of messages per second, but occasionally no events can be seen for several seconds. Thi...

If you are using plain Java, since version 5 we have a handy scheduler class that allows running tasks at fixed rate or with fixed delay: import java.util.concurrent.Executors; import java.util.co...

In the previous article, we learned how to parse excessively large XML files and turn them into RxJava streams. This time let’s look at a large JSON file. We will base our examples on tiny colors.j...

Processing file as a stream turns out to be tremendously effective and convenient. Many people seem to forget that since Java 8 (3+ years!) we can very easily turn any file into a stream of lines: ...

RxJava is missing a factory to create an infinite stream of natural numbers. Such a stream is useful e.g. when you want to assign unique sequence numbers to possibly infinite stream of events by zi...

The title is not a mistake. rx.Observable from RxJava 1.x is a completely different beast than io.reactivex.Observable from 2.x. Blindly upgrading rx dependency and renaming all imports in your pro...

As we already discovered, flatMap() does not preserve the order of original stream. Let’s illustrate this using the GeoNames API example from previous article: public interface GeoNames { Flo...

There are three, seamlessly similar operators in RxJava 2.x: flatMap(), concatMap() and concatMapEager(). All of them accept the same argument - a function from original stream’s individual item to...

While teaching and mentoring RxJava, as well as after authoring a book, I noticed some areas are especially problematic. I decided to publish a bunch of short tips that address most common pitfalls...

TL;DR If your application is failing to obtain new database connection, restarting ActiveMQ broker may help. Interested? The problem with performance Few months ago we experienced a production o...

I don’t always write conference reviews. But when I do, they are about awesome ones. And JCrete was truly awesome. I got invited by Heinz Kabutz himself and this is pretty much the only way to get ...

“Reactive Programming with RxJava: Creating Asynchronous, Event-Based Applications” book was finally published on paper. More than a year of hard work resulted in almost 350 pages packed with RxJav...