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.
Training is one of the most essential factors for growth, evolution and effective collaboration for any UX design team. Design is an ever-changing industry, and there is always something new to learn even for the most experienced professionals. The reality is, not all companies take training seriously, whether the reason is a low budget, lack of time or just not realising its necessity. Meanwhile, investing in training not only boosts the quality of work, but also helps find ways to find easier solutions, work faster and optimize the whole process. Let’s discuss some tips that might help you provide effective and fruitful training for your design team without spending extra budget or wasting time on some questionable training methods.
These days, it seems like everyone is talking about AI. AI here, AI there—AI will replace us all, and so on. I started to wonder: how exactly is AI going to replace us? I decided to dig into this question and examine the technical foundations, mainly to understand it for myself—how exactly is AI supposed to replace us all? Spoiler: it isn’t planning to just yet, but what’s already available today is impressive.
Becoming a lead isn’t just another line in your resume, it’s a mental shift. It’s the moment you go from being a developer to someone responsible for your code and the entire team. Next, you’re also listening, mentoring, negotiating, motivating, and knowing how to find common ground even in challenging situations.
Today, I’m a Dev Lead at EXANTE. We develop internal services for a select group of internal stakeholders. But my journey started long before that — with informal leadership, a few mentorship flops, and plenty of lessons learned the hard way.
Here’s what that path looked like.
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.
Complex systems often appear chaotic or incomprehensible, yet closer examination reveals that such complexity can frequently be reduced to a simple underlying mechanism. By systematically removing layers of emergent behavior, one can uncover a fundamental rule or equation from which the entire system originates.
A few weeks ago, OpenAI announced that Codex is available for Plus users, and I didn’t miss a chance to try it. And today, I’m excited to share a guide to OpenAI’s Codex. As a developer, I’ve found it to be a powerful and practical tool.
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.
In this tutorial, I’ll walk you through everything I’ve learned about using Google Jules — an asynchronous coding agent. I’ve kept the explanations clear and simple, so whether you're an experienced developer or a beginner, you’ll be able to follow along. By the end, you should feel confident working with Jules: assigning tasks, reviewing its output, and making the most of its capabilities. Ready? Let’s dive in. ;)
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.
Ashamed to admit, I still use Swarm in 2025. It's easy to explain, quick to set up, and simple to use. It's a starting point in the world of containers when full-blown Kubernetes is overkill. But Docker's evolution hasn't been the most straightforward. Over time, it began to lack a minimal dynamic proxy for Swarm - one that you run once, which configures traffic routing to microservices automatically - and forget about it. That's how Millau was born - an ingress-proxy and load balancer based on labels. It currently powers its own website and a few other projects.
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!
Users don’t fear changes. They fear wasting time. Why users reject “best” products — and how to win them over.
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.
I recently got my hands on Windsurf AI, and I wanted to share my experience with this AI-first Integrated Development Environment (IDE). If you’re a developer like me, always on the lookout for tools to boost productivity, this might be on your radar. So, is Windsurf AI the real deal? Let’s find out.
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).
My name is Ilya and I’m a Core Developer at Bright Security. In Bright we work on a DAST (Dynamic Application Security Testing) solution that helps development teams find and fix vulnerabilities early, straight from CI/CD. My own path began in full-stack engineering, but almost a decade of shipping production code drew me ever deeper into application security. In this article I’m explaining key approaches on what SAML actually is and how we detect it in Bright using DAST.