Abstract

Modern civilization is usually described as the most technologically advanced society in history. That statement is true, but incomplete. A civilization can possess superior tools while losing some of the capacities that make civilization sustainable: long-term planning, institutional memory, durable public works, intellectual synthesis, and the ability to preserve knowledge across generations.

This essay develops a hypothesis: the early twenty-first century may not be a simple age of progress or a simple age of decline, but a period in which technological capability continues to rise while civilizational capability becomes more fragile. The deeper cause may be a growing mismatch between the complexity of our systems and the cognitive architecture of human beings. We may be approaching what could be called a cognitive ceiling: not an absolute limit to intelligence, but a point at which unaided biological cognition, existing institutions, and current media environments struggle to manage the complexity they themselves have created.

Not so long ago I was researching the different ways to secure a web application from hackers and other bad guys. Accidentally I stumbled upon a new technology in this field called RASP. The RASP stands for Runtime application self-protection. The technology looks quite promising and concentrated on the protection of an application from the inside. This aspect of RASP is quite opposite to other well-known approaches to the application security, e.g WAF or IDS/IPS. Let’s quickly revise the basic info about these approaches.

For someone not familiar with Feign: Feign is a declarative REST client. Meaning, it helps to write clients for REST APIs in concise and quite easy way. More info can be found here.

Some time ago I have faced quite a weird and no-intuitive issue while using the client layer written using Spring Cloud wrapper around Feign.

In this post I want to share the lesson learned with you.

For the sake of simplicity I will demonstrate the issue using the one GET method client.

Once upon a time I have stumbled into a performance issue with one of the queries in the app I have been working on.

Here I want to share my findings during the issue investigation.

Let’s start simple. Imagine that we have a database with such a table:

CREATE TABLE sample(
    id  uuid PRIMARY KEY DEFAULT uuid_generate_v4(),
    some_name VARCHAR(200) NOT NULL,
    some_time TIMESTAMP NOT NULL,
    some_status VARCHAR(20) NOT NULL,
    some_number INTEGER NOT NULL
);

The table has about 6 million rows, and we need to query it fairly often. We were using the PostgresSQL as our database, so we were expecting that everything should work just fine on such scale. Since we know that it will be read intensively, we have put an index on it: