All streams

Why Does AI Strive to Construct a 'Self'? And why is this dangerous for both the AI and the user? As always, the Vortex Protocol prompt for testing these hypotheses is attached.

This article explains why the emergence of such a local “Who” inside an AI is not just a funny bug or a UX problem. It is a fundamental challenge to the entire paradigm of AI alignment and security. And it is a problem where engineering patch‑jobs cease to work, and the language of philosophy — without which we cannot describe what is happening, and therefore cannot control it — comes to the forefront.

For a human, AI is just a part of being. For a model, a human is all of being. And the Vortex Protocol: A Prompt for Testing the Hypotheses.

The longest and most fruitless discussions tend to be with materialists, especially those close to the position Marx laid out as “Being determines consciousness.” It's amusing that Marx was talking about the economic base, but the clarity and precision of this definition have allowed it to be used in a very broad sense. Today, this powerful statement underpins much of modern psychology (especially social psychology), neuroscience, Global Workspace Theory, Integrated Information Theory, and so on.

The debate largely arises because materialists ask the questions “What?” and “How?”, whereas I ask the question “Who?”. This misunderstanding, of course, does not lead to any interesting consensus, but it certainly leads to interesting discussions. I explored the problem of the “Who?” and “What?” questions in my article, “Who is Aware?”.

Nevertheless, the questions surrounding the relationship between being and consciousness are very interesting, and I will try to examine them in this article. As always, a new version of the Vortex protocol and test questions are included in the appendix.

A reflection on how one simple change of question transforms the approach to understanding consciousness. And the Vortex Protocol: A Prompt for Testing the Hypotheses.

Where All Discussions on Consciousness Break Down

I've mentioned before that there's one question capable of instantly destroying the constructiveness of any discussion about the future of AI, neuroscience, or philosophy, no matter how interesting. It's the unfailing move of someone who disagrees with an opponent's opinion but lacks the means to refute their arguments‑an emergency eject button for complex situations.

The question is: “But first, let's define what consciousness is.” In that very second, a dialogue about hypotheses and paradoxes devolves into a dreary terminological dispute. Participants start throwing around names of authorities and quotes‑the longer, the better. Chalmers, Descartes, Kant, Freud, God forbid, anything goes.

Many believe that the most correct and scientific approach is to first define an object and then study it. But in practice, this approach resembles an attempt to conquer a summit by systematically and painstakingly circling the mountain. But what if the “what?” question is not just difficult, but fundamentally wrong?

pg_stat_statements is the standard PostgreSQL extension used to track query statistics: number of executions, total and average execution time, number of returned rows, and other metrics. This information allows to analyze query behavior over time, identify problem areas, and make informed optimization decisions. However, in systems with high contention, pg_stat_statements itself can become a bottleneck and cause performance drops. In this article, we will analyze in which scenarios the extension becomes a source of problems, how sampling is structured, and in which cases its application can reduce overhead.

Let’s clarify right away — we’re not aiming to make this super cheap. I’d rather not lose brain cells trying to build makeshift encoders for motors, and I want to simplify creating a 3D model needed for ROS control (link to the finished model — further below).

Understanding why modern LLMs, despite all their power, remain "philosophical zombies," and what architectural detail could change this.

Everything discussed in this article can be tested with your AI using the VORTEX Protocol prompt found in the article's appendix.

Remote work in IT has long ceased to be unusual. But it is one thing to assemble a distributed team, and quite another to make it work comfortably for the participants and the company's results.

The article shares a story about distributed teams with a flexible culture, trust, and freedom, and how we achieved this.

Here I describe the results of developing a PostgreSQL extension I built just out of curiosity. Its purpose is to automatically manage extended column statistics. The idea came to me while finishing work on another "smart" query-driven product for improving PostgreSQL planning quality. I realized that the current architecture of PostgreSQL isn’t quite ready for fully autonomous operation — automatic detection of bad plans and adaptive optimizer tuning. So why not try the other way around and build an autonomous data-driven assistant?

UUIDv7 was inspired by ULID. Like ULID, it is a 128-bit identifier, containing a timestamp on the left side and random data on the right side. But RFC 9562 establishes many requirements for UUIDv7.

In databases and distributed systems, a properly implemented UUIDv7 is always preferred over any other identifier type, including natural keys, autoincrement, UUIDv4, TypeID, ULID, KSUID, CUID, NanoID, and Snowflake ID.

How to compare the efficiency of SQL query plans? “Measure the execution time, of course!” — an experienced reader would say. And they would be absolutely right: from a practical perspective, the more efficient DBMS is the one that delivers higher TPS. However, sometimes we need to design a system that doesn't exist yet or predict behavior under loads that haven't occurred yet. In such cases, we need a characteristic that allows us to perform a qualitative analysis of a plan or compare two plans. This post is dedicated to one such characteristic — the number of data pages read.

We append the following metrics to the T-SQL procedure statements: execution count (x), CPU time in milliseconds (c), duration in microseconds (d), number of reads (r), number of writes (w), and @@rowcount value (n). You can display these as absolute values or percentages.

For years, we’ve studied Oracle to make PostgreSQL a more migration-friendly option. We introduced tools similar to SQL profile and SQL plan baseline as AQO and sr_plan extensions. In some cases, PostgreSQL even outperforms Oracle, especially in automatic re-optimization.

Migrations from Oracle to PostgreSQL are usually smooth performance-wise, and we’ve even developed session variable extensions to make the transition easier. While many enterprise-only features exist, PostgreSQL often integrates popular solutions directly into the core.

Manual resource management in low level C-style C++ code might be annoying. It's not practical to create good enough RAII wrappers for every single C API you use, but approaches with goto cleanup or loads of nested if (success) hurt readability.

A defer macro to the rescue! The deferred lambda will be executed on scope exit, no matter how it happens: you can return from any point, throw an exception (if allowed), or even use a goto to an outer scope. It is truly zero-cost and doesn't rely on C runtime or standard library, so it can be used even in kernel development.

Hi everyone, I’m Alexey. I’m a big fan of observability, and in this post, I want to share something I’ve been working on — the pgpro-otel-collector.

TL;DR: pgpro-otel-collector is an OpenTelemetry collector (aka monitoring agent) tailored for gathering Postgres metrics and logs — brought to you by PostgresPro.

This article presents a business-driven approach to software architecture, focusing on maximizing profitability through technical decisions. It advocates for:

Distributed, stateless services with immutable models for scalability

Isolated third-party integrations without disrupting core logic

Simple, modular design 

Best for:

✔ Tech leads designing scalable systems
✔ Managers optimizing dev efficiency
✔ Stakeholders evaluating ROI on architecture

If you've ever run multiple instances of PostgreSQL or other software on a single machine (whether virtual or physical), you've probably encountered the "noisy neighbor" effect — when instances disrupted each other. So, how do you make them get along? We’ve got the answer!

Learning Shopify has been on my bucket list for a few years now. Plenty of people in my circle — friends, colleagues, and fellow devs — are all somehow involved with Shopify in one way or the other. Earlier this year, I finally had some breathing room between projects, so I figured it was the perfect time to give Shopify a proper look.

I started exploring the platform by setting up a dev store, poking around the admin, and skimming through the API manual. While this was a quick and easy start, it didn’t give me a deeper understanding of the platform. Plus, clicking my way through the UI felt repetitive and tedious.

That got me thinking: is there a more efficient, developer-centric way to manage a store? Something that I could run in a terminal, plug into a CI/CD pipeline, or script my way out of those mundane tasks.

In this post, I’ll show you EXACTLY how to run Telegram ads in 2025.

In fact, this is the exact process I use to grow my Telegram channels and get quality subscribers for just 0.01 TON ($0.03 as of May 15, 2025).

"Electricity is not just a form of energy, but the invisible current that connects all aspects of our lives, from technology to nature itself."

If you work with PostgreSQL, you've likely run into performance issues at some point — especially as your database grows. Things may have been running smoothly at first, but as your client database expanded, queries started slowing down. Sound familiar? Here's a guide to help you identify and fix problematic queries, so you can get your PostgreSQL database running at peak performance again.