# overhead

Published articles for overhead.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## How fast is C++23's std::flat\_map?

DevFeed: [How fast is C++23's std::flat\_map?](<https://devfeed.tech/articles/how-fast-is-c-23-s-std-flat-map-31465.md>)

Original publisher: [Read original article](<https://lemire.me/blog/2026/09/16/how-fast-is-c23s-stdflat_map/>)

Author: Daniel Lemire

Published: 2026-09-16T20:26:36Z

Content type: article

Language: en

Sources: [Daniel Lemire](<https://devfeed.tech/sources/daniel-lemire.md>)

Topics: [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Library](<https://devfeed.tech/topics/library.md>), [gcc](<https://devfeed.tech/topics/gcc.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [clang](<https://devfeed.tech/topics/clang.md>)

Tags: [array](<https://devfeed.tech/tags/array.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [clang](<https://devfeed.tech/tags/clang.md>), [gcc](<https://devfeed.tech/tags/gcc.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [speed](<https://devfeed.tech/tags/speed.md>), [standard-library](<https://devfeed.tech/tags/standard-library.md>)

### AI overview

This article benchmarks C++23's std::flat_map, a sorted container backed by parallel arrays of keys and values. It explains serialization and loading considerations, then compares insertion and lookup performance with std::map. Random-order insertion becomes quadratic as the container grows, while increasing-order or bulk insertion is much faster; random lookups can also be faster for large maps because std::flat_map uses less memory.

### Source excerpt

C++23 added a new type to the standard library: std::flat_map. There is also a std::flat_set and other variants, but let me focus on std::flat_map. A flat map is a sorted vector of keys next to a vector of values. A query is a binary search over the sorted keys. You need a recent standard library: ... Continue reading How fast is C++23's std::flat_map?

## ML based ranking using Nrtsearch

DevFeed: [ML based ranking using Nrtsearch](<https://devfeed.tech/articles/ml-based-ranking-using-nrtsearch-31461.md>)

Original publisher: [Read original article](<https://engineeringblog.yelp.com/2026/09/ml-ranking-with-nrtsearch.html>)

Author: Mohammad Mohtasham (Software Engineer); Tao Yu (Software Engineer)

Published: 2026-09-16T00:00:00Z

Content type: article

Language: en

Sources: [Yelp](<https://devfeed.tech/sources/yelp.md>)

Topics: [Inference](<https://devfeed.tech/topics/inference.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [recommendation systems](<https://devfeed.tech/topics/recommendation-systems.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [bridge](<https://devfeed.tech/tags/bridge.md>), [inference](<https://devfeed.tech/tags/inference.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [performance](<https://devfeed.tech/tags/performance.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [service](<https://devfeed.tech/tags/service.md>)

### AI overview

Yelp's Nrtsearch Inference Plugin embeds machine-learning ranking directly in the search layer. The article explains the scoring workflow, including model configuration, feature extraction, candidate ranking, and application-specific business logic. It describes how co-locating feature storage and inference reduces network transfer, serialization overhead, and latency compared with a standalone inference service.

### Source excerpt

We've extended Nrtsearch with the Inference Plugin, which embeds ML-based ranking directly in the search layer -- eliminating the need for a standalone scoring service. We use Nrtsearch (read more information on the blog post), a Lucene-based open-source search engine built by Yelp, to power a variety of applications such as business search, reviews search, ad delivery and photo search. In this blog post, we give a high-level overview of the Machine Learning (ML) based scoring workflow in Nrtsearch. We'll show how ML models are configured and loaded, and how different applications use custom business logic to develop, test, and...

## A Model Portfolio for cost-efficient AI across the software development lifecycle

DevFeed: [A Model Portfolio for cost-efficient AI across the software development lifecycle](<https://devfeed.tech/articles/a-model-portfolio-for-cost-efficient-ai-across-the-software-development-lifecycle-32256.md>)

Original publisher: [Read original article](<https://medium.com/data-science-at-microsoft/a-model-portfolio-for-cost-efficient-ai-across-the-software-development-lifecycle-f33295b38d80?source=rss----a6e43238cdaf---4>)

Author: Praveen Sidda

Published: 2026-09-01T07:16:01Z

Content type: article

Language: en

Sources: [Data Science at Microsoft](<https://devfeed.tech/sources/data-science-at-microsoft.md>)

Topics: [AI Development](<https://devfeed.tech/topics/ai-development.md>), [AI Models](<https://devfeed.tech/topics/ai-models.md>), [Model Routing](<https://devfeed.tech/topics/model-routing.md>), [sdlc](<https://devfeed.tech/topics/sdlc.md>), [Agile](<https://devfeed.tech/topics/agile.md>), [Developer experience](<https://devfeed.tech/topics/developer-experience.md>), [Compression](<https://devfeed.tech/topics/compression.md>), [Requirements](<https://devfeed.tech/topics/requirements.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>), [Code review](<https://devfeed.tech/topics/code-review.md>)

Tags: [agentic-sdlc](<https://devfeed.tech/tags/agentic-sdlc.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-cost-optimization](<https://devfeed.tech/tags/ai-cost-optimization.md>), [ai-models](<https://devfeed.tech/tags/ai-models.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [compression](<https://devfeed.tech/tags/compression.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [github-copilot](<https://devfeed.tech/tags/github-copilot.md>), [llm](<https://devfeed.tech/tags/llm.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [requirements](<https://devfeed.tech/tags/requirements.md>), [software-development](<https://devfeed.tech/tags/software-development.md>)

### AI overview

The article examines whether routing software development tasks across a portfolio of AI models can reduce costs compared with using one premium model. It reports that lower-cost models handled well-defined tasks, while premium models were reserved for architecture, implementation, and code review; context compression reduced token usage but risked losing important technical details.

### Source excerpt

Image generated by AIWhat one controlled experiment taught me about matching model capability to developer work Topic: Can intelligently routing developer tasks across different AI models outperform relying on a single premium model? In this article, I put that question to the test by mapping software development lifecycle (SDLC) stages to a portfolio of AI models and comparing the outcomes. Motivation As AI becomes embedded throughout the AI-Native Development Lifecycle (AIDLC), an evolution of the traditional Software Development Lifecycle (SDLC), its cost is no longer tied to a single prompt. A single developer task can involve multiple model calls, each carrying source files, conversation history, tool definitions, and generated output. Applying the most capable model to every interaction is straightforward, but it also consumes premium model capacity on tasks that less expensive models can often complete just as effectively. This raises an important question for engineering organizations: How can teams reduce the cost of AI-assisted development without compromising quality, reliability, or the developer experience? My first instinct was to reduce token consumption. Context compression appeared to be the most direct path to lowering inference costs by shortening prompts. Although it reduced token usage, it also introduced risk. Important constraints and technical details could be lost, affecting downstream tasks. Source code, stack traces, and active instructions proved to be especially poor candidates for lossy compression. That experience shifted my focus. The objective was not to process fewer tokens, but to complete developer tasks successfully at a lower overall cost. I then experimented with model allocation. Lower-cost models handled well-defined tasks such as requirements synthesis, planning, routine test generation, deployment artifacts, and final summaries, while premium models were reserved for architecture, implementation, and code review. This appro

## Foreign keys are not overhead, and the thing you measured was a missing index

DevFeed: [Foreign keys are not overhead, and the thing you measured was a missing index](<https://devfeed.tech/articles/foreign-keys-are-not-overhead-and-the-thing-you-measured-was-a-missing-index-39597.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/45-foreign-keys-are-not-overhead/>)

Author: hello@ankit-rana.com

Published: 2026-08-30T00:00:00Z

Content type: opinion

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [Database](<https://devfeed.tech/topics/database.md>), [integrity](<https://devfeed.tech/topics/integrity.md>)

Tags: [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [foreign-keys](<https://devfeed.tech/tags/foreign-keys.md>), [indexing](<https://devfeed.tech/tags/indexing.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [referential-integrity](<https://devfeed.tech/tags/referential-integrity.md>), [schema-design](<https://devfeed.tech/tags/schema-design.md>)

### AI overview

The article explains that the measured cost of a slow parent delete is usually caused by a missing index on the child table's foreign-key column, not by foreign-key checking itself. It argues that dropping the constraint merely moves referential-integrity enforcement into application code and can allow orphaned records.

### Source excerpt

A foreign key check is an index lookup against a primary key that is almost certainly already in cache, which is close to the cheapest thing a database does. The expensive case people measure is a parent delete with no index on the child's referencing column, which forces a full scan of the child table per deleted row, and that is a missing index rather than a cost of the constraint. Dropping the key does not remove the work, it moves the integrity guarantee into application code where nothing reports when it stops holding.

## From slow tests to slow production: Debugging with Stackprof

DevFeed: [From slow tests to slow production: Debugging with Stackprof](<https://devfeed.tech/articles/from-slow-tests-to-slow-production-debugging-with-stackprof-33519.md>)

Original publisher: [Read original article](<https://www.aha.io/engineering/articles/debugging-with-stack-prof>)

Published: 2026-08-13T00:00:00Z

Content type: tutorial

Language: en

Sources: [Aha! Engineering Blog](<https://devfeed.tech/sources/aha-engineering-blog.md>)

Topics: [debugging](<https://devfeed.tech/topics/debugging.md>), [Tooling](<https://devfeed.tech/topics/tooling.md>), [RSpec](<https://devfeed.tech/topics/rspec.md>), [Databases](<https://devfeed.tech/topics/databases.md>)

Tags: [ci](<https://devfeed.tech/tags/ci.md>), [cpu-time](<https://devfeed.tech/tags/cpu-time.md>), [database](<https://devfeed.tech/tags/database.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [logs](<https://devfeed.tech/tags/logs.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [performance](<https://devfeed.tech/tags/performance.md>), [production-debugging](<https://devfeed.tech/tags/production-debugging.md>), [profiling](<https://devfeed.tech/tags/profiling.md>), [rspec](<https://devfeed.tech/tags/rspec.md>), [snapshots](<https://devfeed.tech/tags/snapshots.md>), [tests](<https://devfeed.tech/tags/tests.md>), [timing](<https://devfeed.tech/tags/timing.md>)

### AI overview

An investigation into tests that became six times slower traces the stall to code generating example data and Active Record callbacks. The article explains using Stackprof with RSpec to profile the test, including I/O time, and reports that the test spent 71% of its time sleeping.

### Source excerpt

One morning, a developer announced in our Slack channel that some tests were failing on our main branch. The cause of the failures was not obvious. No recent PRs seemed related, and neither the code nor the tests had changed in a long time. The test

## Introducing the J2sw MTU and Encapsulation Calculator

DevFeed: [Introducing the J2sw MTU and Encapsulation Calculator](<https://devfeed.tech/articles/introducing-the-j2sw-mtu-and-encapsulation-calculator-40186.md>)

Original publisher: [Read original article](<https://blog.j2sw.com/resources/mtu-encapsulation-calculator/>)

Author: j2sw

Published: 2026-07-28T16:37:53Z

Content type: tutorial

Language: en

Sources: [Justin Wilson (j2sw)](<https://devfeed.tech/sources/justin-wilson-j2sw.md>)

Topics: [Network](<https://devfeed.tech/topics/network.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [Ethernet](<https://devfeed.tech/topics/ethernet.md>), [VXLAN](<https://devfeed.tech/topics/vxlan.md>)

Tags: [calculator](<https://devfeed.tech/tags/calculator.md>), [cisco](<https://devfeed.tech/tags/cisco.md>), [ethernet](<https://devfeed.tech/tags/ethernet.md>), [fragmentation](<https://devfeed.tech/tags/fragmentation.md>), [gre](<https://devfeed.tech/tags/gre.md>), [headers](<https://devfeed.tech/tags/headers.md>), [ipsec](<https://devfeed.tech/tags/ipsec.md>), [ipv4](<https://devfeed.tech/tags/ipv4.md>), [ipv6](<https://devfeed.tech/tags/ipv6.md>), [juniper](<https://devfeed.tech/tags/juniper.md>), [mikrotik](<https://devfeed.tech/tags/mikrotik.md>), [mpls](<https://devfeed.tech/tags/mpls.md>), [mtu](<https://devfeed.tech/tags/mtu.md>), [network-engineering-resources](<https://devfeed.tech/tags/network-engineering-resources.md>), [network-tools](<https://devfeed.tech/tags/network-tools.md>), [network-troubleshooting](<https://devfeed.tech/tags/network-troubleshooting.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [payload](<https://devfeed.tech/tags/payload.md>), [pppoe](<https://devfeed.tech/tags/pppoe.md>), [vlan](<https://devfeed.tech/tags/vlan.md>), [vxlan](<https://devfeed.tech/tags/vxlan.md>)

### AI overview

The article introduces the J2SW MTU and Encapsulation Calculator, which estimates inner IP MTU and required underlay MTU for combinations of PPPoE, GRE, VLAN, MPLS, VXLAN, and other encapsulations. It explains how Layer 2 tags affect Ethernet frame size separately from IP MTU and describes overhead calculations, including cases where fragmentation can be avoided.

### Source excerpt

Ever wondered what the effects of different combinations of PPPoE, GRE, and others have on the MTU of a packet? I am excited to announce the first of many J2 Network tools: the J2SW MTU and Encapsulation Calculator. You select the service MTU and the encapsulation used on the path. The calculator then works out ... Read more The post Introducing the J2sw MTU and Encapsulation Calculator appeared first on Justin Wilson (j2sw).

## OTel-Arrow Phase 2: From Efficient Transport to Efficient Telemetry Pipelines

DevFeed: [OTel-Arrow Phase 2: From Efficient Transport to Efficient Telemetry Pipelines](<https://devfeed.tech/articles/otel-arrow-phase-2-from-efficient-transport-to-efficient-telemetry-pipelines-32578.md>)

Original publisher: [Read original article](<https://opentelemetry.io/blog/2026/otel-arrow-phase-2/>)

Author: OpenTelemetry Authors; Docs CC BY

Published: 2026-06-13T00:47:46Z

Content type: article

Language: en

Sources: [Blog on OpenTelemetry](<https://devfeed.tech/sources/blog-on-opentelemetry.md>)

Topics: [OpenTelemetry](<https://devfeed.tech/topics/opentelemetry.md>), [telemetry](<https://devfeed.tech/topics/telemetry.md>), [Structured-data](<https://devfeed.tech/topics/structured-data.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Instrumentation](<https://devfeed.tech/topics/instrumentation.md>)

Tags: [apache-arrow](<https://devfeed.tech/tags/apache-arrow.md>), [memory](<https://devfeed.tech/tags/memory.md>), [opentelemetry](<https://devfeed.tech/tags/opentelemetry.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>), [processors](<https://devfeed.tech/tags/processors.md>), [rust](<https://devfeed.tech/tags/rust.md>), [telemetry](<https://devfeed.tech/tags/telemetry.md>)

### AI overview

This article presents Phase 2 of OTel-Arrow, which uses Apache Arrow not only for transport through OTAP but also as the internal representation of telemetry pipelines. It describes the Rust-based OTel-Arrow Dataflow Engine and reports substantially lower transport and processing costs when telemetry remains on the OTAP path end to end.

### Source excerpt

Phase 1 of OTel-Arrow established OTAP, the OpenTelemetry Arrow Protocol, as an efficient transport protocol for OpenTelemetry. Apache Arrow is a language-independent, columnar in-memory format designed to move and process structured data efficiently across systems. We demonstrated that telemetry could be transported with significantly lower network overhead while preserving compatibility with the OpenTelemetry data model. Phase 2 asked a different question: what happens if Arrow is used not only on the wire, but also as the representation the pipeline works with internally?

## Recent lld/ELF performance improvements

DevFeed: [Recent lld/ELF performance improvements](<https://devfeed.tech/articles/recent-lld-elf-performance-improvements-31121.md>)

Original publisher: [Read original article](<https://maskray.me/blog/2026-04-12-recent-lld-elf-performance-improvements>)

Published: 2026-04-12T07:00:00Z

Content type: article

Language: en

Sources: [MaskRay](<https://devfeed.tech/sources/maskray.md>)

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [benchmarking](<https://devfeed.tech/topics/benchmarking.md>), [clang](<https://devfeed.tech/topics/clang.md>), [Chromium](<https://devfeed.tech/topics/chromium.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [chromium](<https://devfeed.tech/tags/chromium.md>), [clang](<https://devfeed.tech/tags/clang.md>), [gc](<https://devfeed.tech/tags/gc.md>), [gdb](<https://devfeed.tech/tags/gdb.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [linker](<https://devfeed.tech/tags/linker.md>), [lld](<https://devfeed.tech/tags/lld.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [macos](<https://devfeed.tech/tags/macos.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [patches](<https://devfeed.tech/tags/patches.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

This article reports LLVM lld/ELF linker performance improvements from parallelizing link phases and reducing task-runtime overhead. Benchmarks show a 1.34x speedup over lld 22.1 for a Release+Asserts clang link and a 1.09x speedup for a Chromium debug link, while mold and wild remain faster in the comparisons described.

### Source excerpt

Updated in 2026-05. Since the LLVM 22 branch was cut, I've landed patches that parallelize more link phases and cut task-runtime overhead. This post compares current main against lld 22.1, mold, and wild. Headline: a Release+Asserts clang --gc-sections link is 1.34x as fast as lld 22.1; Chromium debug with --gdb-index is 1.09x as fast. mold and wild are still ahead -- the last section explains why.

## The Glue Problem in Modern AI Development

DevFeed: [The Glue Problem in Modern AI Development](<https://devfeed.tech/articles/the-glue-problem-in-modern-ai-development-19881.md>)

Original publisher: [Read original article](<https://www.digitalocean.com/blog/glue-problem-ai-development>)

Author: James Skelton

Published: 2026-04-02T21:30:07Z

Content type: article

Language: en

Sources: [DigitalOcean](<https://devfeed.tech/sources/digitalocean.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [AI Platform](<https://devfeed.tech/topics/ai-platform.md>), [Development](<https://devfeed.tech/topics/development.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [Inference](<https://devfeed.tech/topics/inference.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-development](<https://devfeed.tech/tags/ai-development.md>), [ai-ml](<https://devfeed.tech/tags/ai-ml.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [developers](<https://devfeed.tech/tags/developers.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [fragmentation](<https://devfeed.tech/tags/fragmentation.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [overhead](<https://devfeed.tech/tags/overhead.md>)

### AI overview

The article examines how fragmented AI infrastructure creates a glue-code problem for developers. It argues that integrated cloud platforms can reduce integration work, operational overhead, and total cost of ownership when deploying and scaling AI applications.

### Source excerpt

AI is now central to modern software development. Teams across industries are turning to AI to solve product and workflow problems in software. But building production systems is still complex. The hardest part of deploying AI isn't the model, it's everything around it. That complexity becomes a glue-code problem when storage, compute, orchestration, networking, authentication, and inference live in separate systems with different operating models. The more seams a workflow crosses, the more developer effort shifts from building product logic to wiring services together. A more integrated platform model reduces that burden. This article examines what it takes to deploy and operate AI applications in today's cloud landscape. Using two examples, we will compare the process in two landscapes: a neocloud combined with a hyperscaler versus a vertically integrated cloud stack. While surface-level costs may look similar, the integrated model offers clear advantages in efficiency by reducing the time developers spend writing glue code and managing the problems that emerge as AI products scale. Key Takeaways The biggest cost in AI systems isn't infrastructure: it's integration. Fragmented, multi-provider stacks force developers to spend time writing and maintaining glue code instead of building product features, turning engineering effort into the real cost center. Raw infrastructure pricing is no longer the differentiator; total cost of ownership is. Even when platform costs are nearly identical, the added complexity of cross-cloud orchestration increases operational overhead, failure points, and staffing requirements at scale. The future of AI platforms is vertical integration, not more tools. Platforms that unify compute, storage, and inference reduce friction, accelerate development, and allow smaller teams to build and scale AI applications more efficiently. The Real Problem Is Fragmentation Consider the modern landscape for AI deployment. AI applications rely on far mo

## How a Learning Project Became Our Modern Mobile Test Framework

DevFeed: [How a Learning Project Became Our Modern Mobile Test Framework](<https://devfeed.tech/articles/how-a-learning-project-became-our-modern-mobile-test-framework-28058.md>)

Original publisher: [Read original article](<https://tech.trivago.com/post/2026-02-18-how-a-learning-project-became-our-modern-mobile-test-framework/>)

Author: Raymond Saba I'm an SDET who enjoys building test automation; Finding Ways

Published: 2026-02-18T00:00:00Z

Content type: article

Language: en

Sources: [Trivago](<https://devfeed.tech/sources/trivago.md>)

Topics: [Mobile](<https://devfeed.tech/topics/mobile.md>), [Automation](<https://devfeed.tech/topics/automation.md>), [webDriver](<https://devfeed.tech/topics/webdriver.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Java](<https://devfeed.tech/topics/java.md>)

Tags: [appium](<https://devfeed.tech/tags/appium.md>), [automation](<https://devfeed.tech/tags/automation.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [java](<https://devfeed.tech/tags/java.md>), [migration](<https://devfeed.tech/tags/migration.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [modularity](<https://devfeed.tech/tags/modularity.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [quality-assurance](<https://devfeed.tech/tags/quality-assurance.md>), [standards](<https://devfeed.tech/tags/standards.md>), [threads](<https://devfeed.tech/tags/threads.md>), [webdriver](<https://devfeed.tech/tags/webdriver.md>)

### AI overview

This engineering article describes how trivago's aging homegrown mobile automation framework evolved into a shared iOS and Android test framework. It covers the transition from Appium 1 to Appium 2 and later Appium 3, including a rewrite based on W3C WebDriver standards, platform-specific drivers, modularity, and parallel execution with threads in one JVM.

### Source excerpt

About six years ago, our mobile automation setup was showing its age. It was a small, homegrown framework that had worked "well enough" for a long time, until we tried to upgrade Java and a few ...

## What is index overhead on writes?

DevFeed: [What is index overhead on writes?](<https://devfeed.tech/articles/what-is-index-overhead-on-writes-33673.md>)

Original publisher: [Read original article](<https://www.depesz.com/2026/01/06/what-is-index-overhead-on-writes/>)

Author: depesz

Published: 2026-01-06T11:57:10Z

Content type: article

Language: en

Sources: [select \* from depesz;](<https://devfeed.tech/sources/select-from-depesz.md>)

Topics: [data](<https://devfeed.tech/topics/data.md>)

Tags: [benchmark](<https://devfeed.tech/tags/benchmark.md>), [btree](<https://devfeed.tech/tags/btree.md>), [delete](<https://devfeed.tech/tags/delete.md>), [gin](<https://devfeed.tech/tags/gin.md>), [index](<https://devfeed.tech/tags/index.md>), [insert](<https://devfeed.tech/tags/insert.md>), [operations](<https://devfeed.tech/tags/operations.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [performance](<https://devfeed.tech/tags/performance.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [speed](<https://devfeed.tech/tags/speed.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>), [uncategorized](<https://devfeed.tech/tags/uncategorized.md>), [update](<https://devfeed.tech/tags/update.md>)

### AI overview

The article measures how indexes affect write performance using PostgreSQL 18 and a one-million-row test table. It reports that loading performance decreases as indexes are added, and that a roughly 3.6-fold increase in storage corresponded to an eightfold slowdown in the tested case. A single wide index performed better than ten separate indexes, though the author notes that the configurations solve different computational problems.

### Source excerpt

One of things people learn is that adding indexes isn't free. All write operations (insert, update, delete) will be slower - well, they have to update index. But realistically - how much slower? Full tests should involve lots of operations, on realistic data, but I just wanted to see some basic info. So I figured ... Continue reading "What is index overhead on writes?"

## Consider using JSON arrays instead of JSON objects for serialisation

DevFeed: [Consider using JSON arrays instead of JSON objects for serialisation](<https://devfeed.tech/articles/consider-using-json-arrays-instead-of-json-objects-for-serialisation-28935.md>)

Original publisher: [Read original article](<https://blog.jooq.org/consider-using-json-arrays-instead-of-json-objects-for-serialisation/>)

Author: lukaseder

Published: 2025-08-11T12:43:10Z

Content type: opinion

Language: en

Sources: [jOOQ](<https://devfeed.tech/sources/jooq.md>)

Topics: [JSON](<https://devfeed.tech/topics/json.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [Structured-data](<https://devfeed.tech/topics/structured-data.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [compression](<https://devfeed.tech/tags/compression.md>), [java](<https://devfeed.tech/tags/java.md>), [jooq](<https://devfeed.tech/tags/jooq.md>), [json](<https://devfeed.tech/tags/json.md>), [json-array](<https://devfeed.tech/tags/json-array.md>), [json-object](<https://devfeed.tech/tags/json-object.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [performance](<https://devfeed.tech/tags/performance.md>), [sql](<https://devfeed.tech/tags/sql.md>), [sql-json](<https://devfeed.tech/tags/sql-json.md>)

### AI overview

The article explains why jOOQ serialises some internal result data as JSON arrays of arrays instead of JSON objects. Positional access can be faster and avoids problems caused by duplicate column names, but the choice is a tradeoff and depends on whether people need to inspect the JSON or consume the API.

### Source excerpt

When implementing the awesome MULTISET operator in jOOQ, its implementation mostly relied on SQL/JSON support of various RDBMS. In short, while standard SQL supports nested collections via ARRAY or MULTISET operators like this: This is poorly supported in most RDBMS, so jOOQ emulates it using SQL/JSON as follows (or similar): Wait a second. A JSON ... Continue reading Consider using JSON arrays instead of JSON objects for serialisation ->

## Introducing persistent memory

DevFeed: [Introducing persistent memory](<https://devfeed.tech/articles/introducing-persistent-memory-39364.md>)

Original publisher: [Read original article](<https://kt.academy/article/pmem-introducing-persistent-memory>)

Published: 2022-05-12T00:00:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [data](<https://devfeed.tech/topics/data.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [IO](<https://devfeed.tech/topics/io.md>), [servers](<https://devfeed.tech/topics/servers.md>)

Tags: [hdd](<https://devfeed.tech/tags/hdd.md>), [io](<https://devfeed.tech/tags/io.md>), [latency](<https://devfeed.tech/tags/latency.md>), [memory](<https://devfeed.tech/tags/memory.md>), [nvme](<https://devfeed.tech/tags/nvme.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [performance](<https://devfeed.tech/tags/performance.md>), [ssd](<https://devfeed.tech/tags/ssd.md>), [storage](<https://devfeed.tech/tags/storage.md>), [storage-engine](<https://devfeed.tech/tags/storage-engine.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

An introduction to persistent memory, a non-volatile storage technology that fits in standard DIMM slots. It explains its position between DRAM and storage, its durability and byte addressability, and how applications can use it to avoid block I/O overhead.

### Source excerpt

Let's learn the basics of persistent memory, its characteristics, how it works and the beauty of byte addressability.

## Sharing Thread Pools Across Libraries in Android Applications

DevFeed: [Sharing Thread Pools Across Libraries in Android Applications](<https://devfeed.tech/articles/reduce-reuse-recycle-your-thread-pools-25909.md>)

Original publisher: [Read original article](<https://chao2zhang.medium.com/reduce-reuse-recycle-your-thread-pools-%EF%B8%8F-81e2f54d8a1d?source=rss-d19045640fe------2>)

Author: Chao Zhang

Published: 2021-12-20T18:26:36Z

Content type: tutorial

Language: en

Sources: [Stories by Chao Zhang on Medium](<https://devfeed.tech/sources/stories-by-chao-zhang-on-medium.md>)

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [Android](<https://devfeed.tech/topics/android.md>), [Library](<https://devfeed.tech/topics/library.md>), [App](<https://devfeed.tech/topics/app.md>), [Network](<https://devfeed.tech/topics/network.md>), [Jetpack](<https://devfeed.tech/topics/jetpack.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [app-development](<https://devfeed.tech/tags/app-development.md>), [app-performance](<https://devfeed.tech/tags/app-performance.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [java](<https://devfeed.tech/tags/java.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [memory](<https://devfeed.tech/tags/memory.md>), [okhttp](<https://devfeed.tech/tags/okhttp.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [performance](<https://devfeed.tech/tags/performance.md>), [thread](<https://devfeed.tech/tags/thread.md>), [threading](<https://devfeed.tech/tags/threading.md>), [threads](<https://devfeed.tech/tags/threads.md>), [work](<https://devfeed.tech/tags/work.md>)

### AI overview

This Android development tutorial explains how creating threads for asynchronous tasks can increase memory pressure, scheduling overhead, and context-switching costs. It discusses using thread pools and proposes configuring libraries such as OkHttp and AndroidX WorkManager to share a common pool, while considering the benefits and costs.

### Source excerpt

Photo: Héctor J. Rivas from Unsplash Real-world applications today are mostly multi-threaded. This means developers should be mindful of managing the concurrency of their applications. Mastering the threading can help boost an app's performance. On the other hand, using concurrency without fully understanding it could lead to problems that negatively impact the app's health. For Android applications, every thread is mapped to a system-level thread at runtime. Each thread costs a minimum of 64k of memory on Android, If we always create a thread for any new asynchronous task, we will create memory pressure on the app. The app performance may suffer because spawning up new threads and context switching among threads are both taking up time and resources. If a thread is referenced even if it is not active, it will be kept in memory and can't be cleaned up by the garbage collector. Thread pools can help us manage concurrency more efficiently. ThreadPoolExecutor creates a pool of worker threads and schedules the tasks for them to execute. It can grow the pool size to meet the demand as new tasks arrive, and it can shrink the pool when threads are idle and no longer need to be kept alive. Thread pool, therefore, improves the app performance by reducing the per-task overhead and controls the resource usage by bounding the resources. Thread pool seems the solution to our concurrency headache, and many libraries have adopted this technique, such as OkHttp and AndroidX WorkManager. Each library maintains its own thread pool by default. When we include these libraries in our application, since each library spins up new threads by itself without the awareness of other thread pools, we come full circle. Hundreds of threads exist in our application because those libraries do not know each other. In this story, we are going to walk through an example of configuring libraries to share a common thread pool. We will also summarize the benefits and costs of managing thread pools, as it

## Accommodation Consolidation: How we created an ETL pipeline on cloud

DevFeed: [Accommodation Consolidation: How we created an ETL pipeline on cloud](<https://devfeed.tech/articles/accommodation-consolidation-how-we-created-an-etl-pipeline-on-cloud-27990.md>)

Original publisher: [Read original article](<https://tech.trivago.com/post/2020-03-26-accommodationconsolidationhowwecreatedan/>)

Author: Praneeth Peiris I want

Published: 2020-03-26T00:00:00Z

Content type: article

Language: en

Sources: [Trivago](<https://devfeed.tech/sources/trivago.md>)

Topics: [AWS Glue](<https://devfeed.tech/topics/aws-glue.md>), [AWS Step Functions](<https://devfeed.tech/topics/aws-step-functions.md>), [etl](<https://devfeed.tech/topics/etl.md>), [data](<https://devfeed.tech/topics/data.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>)

Tags: [aws](<https://devfeed.tech/tags/aws.md>), [aws-glue](<https://devfeed.tech/tags/aws-glue.md>), [aws-step-functions](<https://devfeed.tech/tags/aws-step-functions.md>), [backend](<https://devfeed.tech/tags/backend.md>), [batch](<https://devfeed.tech/tags/batch.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [data](<https://devfeed.tech/tags/data.md>), [engineering-culture](<https://devfeed.tech/tags/engineering-culture.md>), [etl](<https://devfeed.tech/tags/etl.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>)

### AI overview

trivago describes a hybrid AWS architecture using AWS Glue and AWS Step Functions to build ETL pipelines for consolidating frequently changing hotel information from hundreds of partners. The approach batches updates to reduce computational overhead and supports separately tested consolidation models and sandbox environments.

### Source excerpt

Imagine you go to your hotel for check-in and they say that your dog is not allowed even though the website clearly states that it is!trivago gets information about millions of accommodat...

## Operator fusion in RxJava 2

DevFeed: [Operator fusion in RxJava 2](<https://devfeed.tech/articles/operator-fusion-in-rxjava-2-38620.md>)

Original publisher: [Read original article](<https://krossovochkin.com/posts/2019_11_02_operator_fusion_in_rxjava_2/>)

Published: 2019-11-02T00:00:00Z

Content type: tutorial

Language: en

Sources: [Vasya Drobushkov](<https://devfeed.tech/sources/vasya-drobushkov.md>)

Topics: [RxJava](<https://devfeed.tech/topics/rxjava.md>), [Library](<https://devfeed.tech/topics/library.md>), [reactive](<https://devfeed.tech/topics/reactive.md>), [backpressure](<https://devfeed.tech/topics/backpressure.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [article](<https://devfeed.tech/tags/article.md>), [backpressure](<https://devfeed.tech/tags/backpressure.md>), [flowable](<https://devfeed.tech/tags/flowable.md>), [memory](<https://devfeed.tech/tags/memory.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [performance](<https://devfeed.tech/tags/performance.md>), [reactive](<https://devfeed.tech/tags/reactive.md>), [rxjava](<https://devfeed.tech/tags/rxjava.md>), [technical](<https://devfeed.tech/tags/technical.md>)

### AI overview

This article explains operator fusion in RxJava 2 as an optimization intended to reduce performance and memory overhead. It first reviews Observable, Flowable, their related observer or subscriber types, and backpressure, then introduces the assembly and subscription stages of an Rx chain.

### Source excerpt

Introduction RxJava is a very powerful library, though it has some issues as well. Specifically performance and memory issues, which come from problems library tries to solve and how the solution is designed from technical perspective. In order to minimize overhead in RxJava there are a number of optimizations, which are called "operator fusion". And we'll talk about them in this article. But first let's recap how RxJava reactive types work and what issues they have.

## Visualizing a column's space overhead using pg\_hexedit

DevFeed: [Visualizing a column's space overhead using pg\_hexedit](<https://devfeed.tech/articles/visualizing-a-column-s-space-overhead-using-pg-hexedit-33662.md>)

Original publisher: [Read original article](<https://pgeoghegan.blogspot.com/2018/05/visualizing-columns-space-overhead.html>)

Author: Peter Geoghegan (noreply@blogger.com)

Published: 2018-05-18T23:11:00Z

Content type: tutorial

Language: en

Sources: [Peter Geoghegan's blog](<https://devfeed.tech/sources/peter-geoghegan-s-blog.md>)

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [structure](<https://devfeed.tech/topics/structure.md>)

Tags: [command-line](<https://devfeed.tech/tags/command-line.md>), [index](<https://devfeed.tech/tags/index.md>), [indexes](<https://devfeed.tech/tags/indexes.md>), [internals](<https://devfeed.tech/tags/internals.md>), [nbtree](<https://devfeed.tech/tags/nbtree.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [pageinspect](<https://devfeed.tech/tags/pageinspect.md>), [pg-hexedit](<https://devfeed.tech/tags/pg-hexedit.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [schema](<https://devfeed.tech/tags/schema.md>), [storage](<https://devfeed.tech/tags/storage.md>)

### AI overview

The article describes a new pg_hexedit capability for annotating the space used by individual columns within PostgreSQL tuples in tables and B-Tree indexes. It explains how tuple metadata enables the feature and discusses how column ordering and types can reduce on-disk storage, particularly for large fact tables and machine-generated event data.

### Source excerpt

pg_hexedit recently gained the ability to annotate the space taken up by each individual column/attribute within each individual tuple. This works with tables, and with B-Tree indexes. I had to come up with a way of passing the pg_hexedit frontend utility the relevant pg_attribute metadata to make this work. This metadata describes the "shape" of individual tuples in a relation (backend code uses a closely related structure called a "tuple descriptor"). My approach works seamlessly in simple cases, but can still be used when manually running the pg_hexedit command line tool. pg_attribute system catalog table with column annotations/tags This new capability could be applied to optimizing the data layout of a table that is expected to eventually have a massive number of rows. Carefully choosing the order and type of each column can reduce the total on-disk footprint of a table by an appreciable amount, especially when the final table ends up with several 1 byte columns that get packed together. I am aware of several PostgreSQL users that found it worthwhile to have a highly optimized tuple layout, going so far as to use their own custom dataypes. Alignment-aware micro-optimization of a Postgres client application's schema won't help much in most cases, but it can help noticeably with things like fact tables, or tables that contain machine-generated event data. Developing a sense of proportion around storage overhead should now be easier, and more intuitive.

## Strong Conventions Make Hiring Easier

DevFeed: [Strong Conventions Make Hiring Easier](<https://devfeed.tech/articles/strong-conventions-make-hiring-easier-28411.md>)

Original publisher: [Read original article](<https://eaf4.com/strong-conventions-make-hiring-easier/>)

Author: Edward Faulkner

Published: 2016-11-10T17:42:28Z

Content type: opinion

Language: en

Sources: [Edward Faulkner](<https://devfeed.tech/sources/edward-faulkner.md>)

Topics: [Ember](<https://devfeed.tech/topics/ember.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [books](<https://devfeed.tech/tags/books.md>), [ember](<https://devfeed.tech/tags/ember.md>), [git](<https://devfeed.tech/tags/git.md>), [hiring](<https://devfeed.tech/tags/hiring.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [team](<https://devfeed.tech/tags/team.md>), [training](<https://devfeed.tech/tags/training.md>)

### AI overview

Strong conventions and shared solutions in the Ember community can make hiring easier by reducing onboarding overhead, enabling realistic work evaluations, and helping both experienced and junior developers become productive more quickly.

### Source excerpt

The most reliable way to evaluate programmer candidates is to hire them to do a bit of realistic work. This is widely understood, but not widely practiced. The biggest barrier is finding projects for them to work on. In most organizations, the overhead of getting a new person started is

## Over-delegating JavaScript events

DevFeed: [Over-delegating JavaScript events](<https://devfeed.tech/articles/over-delegating-javascript-events-32305.md>)

Original publisher: [Read original article](<https://jack.ofspades.com/over-delegating-javascript-events/>)

Author: Jack Tarantino

Published: 2016-01-27T03:33:40Z

Content type: tutorial

Language: en

Sources: [Jacopo Tarantino](<https://devfeed.tech/sources/jacopo-tarantino.md>)

Topics: [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Web Development](<https://devfeed.tech/topics/web-development.md>), [interactive web experiences](<https://devfeed.tech/topics/interactive-web-experiences.md>)

Tags: [best-practices](<https://devfeed.tech/tags/best-practices.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [scope](<https://devfeed.tech/tags/scope.md>), [triggers](<https://devfeed.tech/tags/triggers.md>)

### AI overview

The article explains that JavaScript event delegation is useful for handling events from many nodes with one listener, but delegating too high in the DOM can run unnecessary callbacks and allow events to affect unrelated components. It recommends scoping listeners to the nearest appropriate parent and stopping further propagation to reduce unintended behavior and overhead.

### Source excerpt

Delegating event listeners in JavaScript is generally a good practice. It allows us to create only one event listener for events that might be triggered on a variety of nodes and across multiple contexts. If we're just looking to listen for any given click on a page it would be