<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
  <link href="https://binaryigor.com/feed.xml" rel="self" type="application/atom+xml" />
  <link href="https://binaryigor.com/" rel="alternate" type="text/html" hreflang="en"/>
  <id>https://binaryigor.com/</id>
  
  <title>Binary Igor</title>
  <subtitle>Some things are either 0 or I. Deeper and broader thinking on commanding binary machines; for programmers and developers driven not just to implement, but to understand deeply, innovate, design and lead.</subtitle>
  <updated>2026-03-01T00:00:00Z</updated>

  <author>
    <name>Igor Roztropiński</name>
    <email>igor@binaryigor.com</email>
  </author>

  
    <entry xml:lang="en">
        <title>JSON Documents Performance, Storage and Search: MongoDB vs PostgreSQL</title>
        <id>https://binaryigor.com/json-documents-mongodb-vs-postgresql</id>
        <link href="https://binaryigor.com/json-documents-mongodb-vs-postgresql.html" rel="alternate" type="text/html" />
        <published>2026-03-01T00:00:00Z</published>
        <updated>2026-03-01T00:00:00Z</updated>
        <summary> Does MongoDB still have an edge as a document-oriented database for JSON in particular? Or is Postgres better? Or at least good-enough to stick with it, since it is a more universal database, offering a richer feature set and wider applicability?</summary>
    </entry>

    <entry xml:lang="en">
        <title>Data Consistency: transactions, delays and long-running processes</title>
        <id>https://binaryigor.com/data-consistency-transactions-delays-processes</id>
        <link href="https://binaryigor.com/data-consistency-transactions-delays-processes.html" rel="alternate" type="text/html" />
        <published>2026-01-26T00:00:00Z</published>
        <updated>2026-01-26T00:00:00Z</updated>
        <summary>Data Consistency is simply a need to keep data consistent within a particular boundary and time. There are two main scopes ... Local data is immediately consistent - there are no delays, it appears either in its final form or not at all. In the global scope however, things look totally different.</summary>
    </entry>

    <entry xml:lang="en">
        <title>MySQL vs PostgreSQL Performance: throughput &amp; latency, reads &amp; writes</title>
        <id>https://binaryigor.com/mysql-vs-postgresql-performance</id>
        <link href="https://binaryigor.com/mysql-vs-postgresql-performance.html" rel="alternate" type="text/html" />
        <published>2026-01-05T00:00:00Z</published>
        <updated>2026-01-05T00:00:00Z</updated>
        <summary>MySQL, the Dolphin, and Postgres, the Elephant, are one of the best and most widely used open-source databases. They are often compared across multiple angles: supported features, SQL dialect differences, architecture &amp; internals, resource utilization and - performance. Today, we will jump into performance as deeply and broadly as possible - running many (17) test cases with all kinds of queries and workloads.</summary>
    </entry>

    <entry xml:lang="en">
        <title>Authentication: who are you? Proofs are passwords, codes and keys</title>
        <id>https://binaryigor.com/authentication-who-are-you-proofs</id>
        <link href="https://binaryigor.com/authentication-who-are-you-proofs.html" rel="alternate" type="text/html" />
        <published>2025-12-14T00:00:00Z</published>
        <updated>2025-12-14T00:00:00Z</updated>
        <summary>In many systems, various actions can only be performed as some kind of Identity. We must authenticate ourselves by proving who we are. Authentication fundamentally is just an answer to this question: who are you and can you prove it is true?</summary>
    </entry>

    <entry xml:lang="en">
        <title>Modular Monolith and Microservices: parallel work, independent deployments and organization scalability</title>
        <id>https://binaryigor.com/modular-monolith-and-microservices-work-deployments-scalability</id>
        <link href="https://binaryigor.com/modular-monolith-and-microservices-work-deployments-scalability.html" rel="alternate" type="text/html" />
        <published>2025-11-28T00:00:00Z</published>
        <updated>2025-11-28T00:00:00Z</updated>
        <summary>One of the most useful traits of Modularity done properly is Autonomy: modules - folders or versioned packages in a modular monolith, separately deployed microservices - are as independent from and as unaware of each other as possible. It has at least three important implications.</summary>
    </entry>

    <entry xml:lang="en">
        <title>Modular Monolith and Microservices: Data ownership, boundaries, consistency and synchronization</title>
        <id>https://binaryigor.com/modular-monolith-and-microservices-data</id>
        <link href="https://binaryigor.com/modular-monolith-and-microservices-data.html" rel="alternate" type="text/html" />
        <published>2025-11-14T00:00:00Z</published>
        <updated>2025-11-14T00:00:00Z</updated>
        <summary>Virtually every module - folder or versioned package in a modular monolith, separately deployed microservice - must own or at least read some data to provide its functionality. As we shall see, the degree to which module A needs data from module B is often the degree to which it depends on this module; functionality being another important dimension of dependence. This leads us to the following principles...</summary>
    </entry>

    <entry xml:lang="en">
        <title>Optimistic vs Pessimistic Locking: concurrency control, conflicts, lost updates, retries and blocking</title>
        <id>https://binaryigor.com/optimistic-vs-pessimistic-locking</id>
        <link href="https://binaryigor.com/optimistic-vs-pessimistic-locking.html" rel="alternate" type="text/html" />
        <published>2025-11-04T00:00:00Z</published>
        <updated>2025-11-04T00:00:00Z</updated>
        <summary>In many applications and systems, we must deal with concurrent, often conflicting and possibly lost, updates. This is exactly what the Concurrency Control problem is all about.</summary>
    </entry>

    <entry xml:lang="en">
        <title>Bitcoin Core Code: C++, some Python and a Custom Build System</title>
        <id>https://binaryigor.com/bitcoin-core-code</id>
        <link href="https://binaryigor.com/bitcoin-core-code.html" rel="alternate" type="text/html" />
        <published>2025-08-23T00:00:00Z</published>
        <updated>2025-09-01T00:00:00Z</updated>
        <summary>As we have recently analyzed how the Bitcoin P2P Network works, let's delve into arguably its most important software component - the Bitcoin Core, the reference client and the reference implementation of all aspects of the Bitcoin system. With the main goal of having a few questions answered...</summary>
    </entry>

    <entry xml:lang="en">
        <title>Centralized vs Decentralized Identity tradeoffs: Twitter/X, YouTube, Mastodon, ActivityPub and NOSTR</title>
        <id>https://binaryigor.com/centralized-vs-decentralized-identity-tradeoffs</id>
        <link href="https://binaryigor.com/centralized-vs-decentralized-identity-tradeoffs.html" rel="alternate" type="text/html" />
        <published>2025-07-12T00:00:00Z</published>
        <updated>2025-07-12T00:00:00Z</updated>
        <summary>Social media and various other online platforms require some sort of identity to provide their services and to customize experience to us. What does it mean exactly and how does it work in practice? Currently most, if not all, of these platforms - Twitter/X, YouTube, Reddit, LinkedIn, Facebook, Instagram, GitHub, Amazon, Spotify and the like - are account-based.</summary>
    </entry>

    <entry xml:lang="en">
        <title>EventSQL: events over SQL</title>
        <id>https://binaryigor.com/events-over-sql</id>
        <link href="https://binaryigor.com/events-over-sql.html" rel="alternate" type="text/html" />
        <published>2025-06-14T00:00:00Z</published>
        <updated>2025-06-14T00:00:00Z</updated>
        <summary>Events, and messages more broadly, are a battle-tested way of component to component, process to process, and/or application to application communication ... What if we were able to just use a type of SQL database already managed on our infrastructure to build a scalable Events Platform on top of it?</summary>
    </entry>

    <entry xml:lang="en">
        <title>Bitcoin P2P Network: peer discovery, reachability and resilience</title>
        <id>https://binaryigor.com/bitcoin-p2p-network</id>
        <link href="https://binaryigor.com/bitcoin-p2p-network.html" rel="alternate" type="text/html" />
        <published>2025-04-05T00:00:00Z</published>
        <updated>2025-04-05T00:00:00Z</updated>
        <summary>Peer-to-Peer (P2P) Networks introduce a completely new set of challenges. In the traditional Client-Server Architecture, there is a server and client ... Things work completely differently in the Peer-to-Peer (P2P) Networks. These networks consist of equal peers that communicate directly with each other. Their goal is to be as decentralized as possible and not to have any single point of control or failure.</summary>
    </entry>

    <entry xml:lang="en">
        <title>Multi vs Single Page Apps: user experience, performance, complexity and more</title>
        <id>https://binaryigor.com/multi-vs-single-page-apps</id>
        <link href="https://binaryigor.com/multi-vs-single-page-apps.html" rel="alternate" type="text/html" />
        <published>2025-03-08T00:00:00Z</published>
        <updated>2025-03-08T00:00:00Z</updated>
        <summary>To establish what these differences are, we will go through two implementations of Projects App - one as HTMX MPA and the other as React SPA. This makes our comparison more concrete and objective, since the same functionalities were implemented twice, only approach - MPA vs SPA - is what makes these cases different.</summary>
    </entry>

    <entry xml:lang="en">
        <title>React and HTMX: different abstractions, different tradeoffs</title>
        <id>https://binaryigor.com/react-and-htmx-different-abstractions-different-tradeoffs</id>
        <link href="https://binaryigor.com/react-and-htmx-different-abstractions-different-tradeoffs.html" rel="alternate" type="text/html" />
        <published>2025-01-28T00:00:00Z</published>
        <updated>2025-01-28T00:00:00Z</updated>
        <summary>React and HTMX represent two completely different approaches to building web applications. React approach is JSON centric. It is driven by JSON, a data format that is totally different from what is needed to render web pages or their fragments - HTML ... HTMX approach is HTML centric. It is driven by HTML - data is received in the exactly same way it is required for rendering, there is no need for any transformations.</summary>
    </entry>

    <entry xml:lang="en">
        <title>SQLite DB: simple, in-process, reliable, fast</title>
        <id>https://binaryigor.com/sqlite-db-simple-in-process-reliable-fast</id>
        <link href="https://binaryigor.com/sqlite-db-simple-in-process-reliable-fast.html" rel="alternate" type="text/html" />
        <published>2024-12-24T00:00:00Z</published>
        <updated>2025-02-05T00:00:00Z</updated>
        <summary>I love simplicity. Complexity is our eternal enemy and Simplicity is beautiful; rarely something is as simple as SQLite: a single-file, in-process database. It runs inside our application, there is no need for a separate database server.</summary>
    </entry>

    <entry xml:lang="en">
        <title>MySQL and PostgreSQL: different approaches to solve the same problem</title>
        <id>https://binaryigor.com/mysql-and-postgresql-different-approaches</id>
        <link href="https://binaryigor.com/mysql-and-postgresql-different-approaches.html" rel="alternate" type="text/html" />
        <published>2024-11-11T00:00:00Z</published>
        <updated>2024-11-11T00:00:00Z</updated>
        <summary>Both databases solve the same problem: how to most effectively store and provide access to data, in an ACID-compliant way? ACID compliance might be implemented in various ways and SQL databases can vary quite substantially how they choose to go about it.</summary>
    </entry>

    <entry xml:lang="en">
        <title>HTMX with Shoelace Web Components: using framework-agnostic components in an example app</title>
        <id>https://binaryigor.com/htmx-with-shoelace-framework-agnostic-components-in-an-example-app</id>
        <link href="https://binaryigor.com/htmx-with-shoelace-framework-agnostic-components-in-an-example-app.html" rel="alternate" type="text/html" />
        <published>2024-10-12T00:00:00Z</published>
        <updated>2024-10-12T00:00:00Z</updated>
        <summary>As we already know, HTMX pairs really nicely with Web Components. Shoelace is a popular and mature collection of configurable Web Components, which by definition are framework agnostic. Since writing our own components library is a ton of work, we should rather prefer using something ready and battle tested. Let's then see how this library plays with HTMX by building a real application!</summary>
    </entry>

    <entry xml:lang="en">
        <title>Programmer in Wonderland</title>
        <id>https://binaryigor.com/programmer-in-wonderland</id>
        <link href="https://binaryigor.com/programmer-in-wonderland.html" rel="alternate" type="text/html" />
        <published>2024-09-15T00:00:00Z</published>
        <updated>2024-09-15T00:00:00Z</updated>
        <summary>There are hundreds and thousands of tools and frameworks out there, often solving the same problems or struggling to explain what the problem they are trying to solve is ... Because of this diversity and how powerful some of these tools are, it often feels like Magic. So many things possible, so fast and seemingly without a cost, without tradeoffs. But is it really the case?</summary>
    </entry>

    <entry xml:lang="en">
        <title>Who controls the Internet and How it works?</title>
        <id>https://binaryigor.com/who-controls-the-internet-and-how-it-works</id>
        <link href="https://binaryigor.com/who-controls-the-internet-and-how-it-works.html" rel="alternate" type="text/html" />
        <published>2024-08-31T00:00:00Z</published>
        <updated>2024-08-31T00:00:00Z</updated>
        <summary>We take the Internet, as it is, completely for granted. But have you ever wondered: what it is, how it works and who controls it? At its core, the Internet is just a...</summary>
    </entry>

    <entry xml:lang="en">
        <title>Simple yet Scalable Web Analytics: JSON in SQL with batch inserts</title>
        <id>https://binaryigor.com/simple-yet-scalable-web-analytics</id>
        <link href="https://binaryigor.com/simple-yet-scalable-web-analytics.html" rel="alternate" type="text/html" />
        <published>2024-08-16T00:00:00Z</published>
        <updated>2024-08-16T00:00:00Z</updated>
        <summary>When building landing pages and blogs, we usually want to have some traffic data and its analytics. Monitoring activity on our web pages turns out to be quite useful ... Similarly, when we build web applications, we want to have analytical data to understand the behaviors and interactions of our users.</summary>
    </entry>

    <entry xml:lang="en">
        <title>Modular Monolith: dependencies and communication between Modules</title>
        <id>https://binaryigor.com/modular-monolith-dependencies-and-communication</id>
        <link href="https://binaryigor.com/modular-monolith-dependencies-and-communication.html" rel="alternate" type="text/html" />
        <published>2024-05-19T00:00:00Z</published>
        <updated>2024-05-19T00:00:00Z</updated>
        <summary>Before talking about module communication, it is important to emphasize the consequences of chosen module design. Problems that we will face when communicating between modules, how often and how much of communication there will be, depend mostly on decided modules structure ... Assuming that we have modules that depend very little on each other, but sometimes they do need to talk with each other - how can they and when they should?</summary>
    </entry>

    <entry xml:lang="en">
        <title>HTMX: a setup ready for Production</title>
        <id>https://binaryigor.com/htmx-a-setup-ready-for-production</id>
        <link href="https://binaryigor.com/htmx-a-setup-ready-for-production.html" rel="alternate" type="text/html" />
        <published>2024-05-04T00:00:00Z</published>
        <updated>2024-05-04T00:00:00Z</updated>
        <summary>HTMX is a promising technology that simplifies many things when building web applications/systems ... That is great when it comes to local development and simple experiments, but what about Production?</summary>
    </entry>

    <entry xml:lang="en">
        <title>Load Testing: how many HTTP requests/second can a Single Machine handle?</title>
        <id>https://binaryigor.com/how-many-http-requests-can-a-single-machine-handle</id>
        <link href="https://binaryigor.com/how-many-http-requests-can-a-single-machine-handle.html" rel="alternate" type="text/html" />
        <published>2024-03-28T00:00:00Z</published>
        <updated>2024-03-28T00:00:00Z</updated>
        <summary>When designing systems and deciding on the architecture, I often hear justifying the use of microservices and other complex solutions because of the predicted performance and scalability needs. Out of curiosity then, let's test the limits of an extremely simple approach, the simplest possible one.</summary>
    </entry>

    <entry xml:lang="en">
        <title>Kubernetes: maybe a few Bash/Python scripts is enough</title>
        <id>https://binaryigor.com/kubernetes-maybe-a-few-bash-python-scripts-is-enough</id>
        <link href="https://binaryigor.com/kubernetes-maybe-a-few-bash-python-scripts-is-enough.html" rel="alternate" type="text/html" />
        <published>2024-03-09T00:00:00Z</published>
        <updated>2024-03-28T00:00:00Z</updated>
        <summary>When it comes to the infrastructure of a software system, there are some features that are virtually always needed, independently of the project nature, and some that are additional, optional, or useful only in some projects and contexts ... Infrastructure is a crucial component of every software system: what do we need from it?</summary>
    </entry>

    <entry xml:lang="en">
        <title>HTMX and Web Components: a Perfect Match</title>
        <id>https://binaryigor.com/htmx-and-web-components-a-perfect-match</id>
        <link href="https://binaryigor.com/htmx-and-web-components-a-perfect-match.html" rel="alternate" type="text/html" />
        <published>2023-12-21T00:00:00Z</published>
        <updated>2023-12-21T00:00:00Z</updated>
        <summary>Web Components are a set of browser APIs that allow us to create custom HTML elements. They are one of the major things that SPA (Single Page Application) frameworks have been giving us for a long time ... HTMX is highly interesting, useful and a promising technology. It simplifies many things and allows us to build SPA or SPA-like applications without complex tooling, dependencies, frameworks and mostly without writing application-specific JavaScript code.</summary>
    </entry>

    <entry xml:lang="en">
        <title>Modular Monolith and Microservices: Modularity is what truly matters</title>
        <id>https://binaryigor.com/modular-monolith-and-microservices-modularity-is-what-truly-matters</id>
        <link href="https://binaryigor.com/modular-monolith-and-microservices-modularity-is-what-truly-matters.html" rel="alternate" type="text/html" />
        <published>2023-11-26T00:00:00Z</published>
        <updated>2023-11-26T00:00:00Z</updated>
        <summary>Modularity is a crucial concept when designing and creating software. Independent of whether our chosen architecture style is to have a single unit of deployment - Monolith or multiple units of deployment - Microservices/Services. It is a quality that should be treated completely independent of how many deployable units of software we choose to have.</summary>
    </entry>

    <entry xml:lang="en">
        <title>Unit, Integration, E2E, Contract, X tests: what should we focus on?</title>
        <id>https://binaryigor.com/unit-integration-e2e-contract-x-tests-what-should-we-focus-on</id>
        <link href="https://binaryigor.com/unit-integration-e2e-contract-x-tests-what-should-we-focus-on.html" rel="alternate" type="text/html" />
        <published>2023-11-04T00:00:00Z</published>
        <updated>2023-11-04T00:00:00Z</updated>
        <summary>When we write software, we intend it to be used in some, usually predefined and desirable, way. All software has some specification, either explicitly described or implicitly assumed. How do we know that it (software) works? We can test it manually, using all of its features and functionalities. Unfortunately, this approach breaks down pretty fast.</summary>
    </entry>

    <entry xml:lang="en">
        <title>Index: a crucial data structure for search performance</title>
        <id>https://binaryigor.com/index-a-crucial-data-structure-for-search-performance</id>
        <link href="https://binaryigor.com/index-a-crucial-data-structure-for-search-performance.html" rel="alternate" type="text/html" />
        <published>2023-10-08T00:00:00Z</published>
        <updated>2023-10-08T00:00:00Z</updated>
        <summary>There are many variations and types of it, depending on the underlying database/search engine and its purpose, but the core concept is always the same: let's have an additional data structure that points to/references the original data and makes searching fast.</summary>
    </entry>

    <entry xml:lang="en">
        <title>HTMX: simpler web-based app/system</title>
        <id>https://binaryigor.com/htmx-simpler-web-based-app-or-system</id>
        <link href="https://binaryigor.com/htmx-simpler-web-based-app-or-system.html" rel="alternate" type="text/html" />
        <published>2023-09-22T00:00:00Z</published>
        <updated>2023-09-22T00:00:00Z</updated>
        <summary>Nowadays, when we develop web-based app/system it is most likely built as SPA, which is a single page application. We should ask, why have we done that? Why have we switched from multi page applications, where the browser supported all of these functions out of the box, functions that we now need to recreate by writing custom JavaScript code?</summary>
    </entry>

    <entry xml:lang="en">
        <title>Indexing, Partitioning, Sharding - it is all about reducing the search space</title>
        <id>https://binaryigor.com/reducing-the-search-space</id>
        <link href="https://binaryigor.com/reducing-the-search-space.html" rel="alternate" type="text/html" />
        <published>2023-09-09T00:00:00Z</published>
        <updated>2023-09-09T00:00:00Z</updated>
        <summary>Whenever I think about optimizing certain data query, be it SQL (mostly) or NoSQL, I find it useful to think about these problems as search space problems. In other words, how much data need to be scanned/checked in order for my query to be fulfilled?</summary>
    </entry>
</feed>