# ordering

Published articles for ordering.

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

## \[$\] Adding BPF to blk-iocost

DevFeed: [\[$\] Adding BPF to blk-iocost](<https://devfeed.tech/articles/adding-bpf-to-blk-iocost-26937.md>)

Original publisher: [Read original article](<https://lwn.net/Articles/1093661/>)

Author: corbet

Published: 2026-09-15T14:37:30Z

Content type: article

Language: en

Sources: [LWN.net](<https://devfeed.tech/sources/lwn-net.md>)

Topics: [Kernel](<https://devfeed.tech/topics/kernel.md>), [IO](<https://devfeed.tech/topics/io.md>), [ordering](<https://devfeed.tech/topics/ordering.md>), [Operating system](<https://devfeed.tech/topics/operating-system.md>)

Tags: [kernels](<https://devfeed.tech/tags/kernels.md>), [loading](<https://devfeed.tech/tags/loading.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

This article discusses a patch series that would make the Linux blk-iocost I/O controller more flexible by allowing a BPF program to make cost decisions. It places the change in the context of block I/O scheduling for modern solid-state drives, where fairness and high throughput are important.

### Source excerpt

The scheduling of block I/O requests has long been a challenge for operating-system kernels. For many years, the performance characteristics of rotating drives meant that putting considerable resources into request ordering was worthwhile. In a world with fast, solid-state drives, scheduling is more concerned with enforcing fairness between competing users while being fast enough to keep up with drives that can perform millions of I/O operations per second. The blk-iocost I/O controller was designed for the solid-state world and generally performs well, but there is always a desire to do better. This patch series from Tao Cui aims to make blk-iocost more flexible by enabling the loading of a BPF program to make cost decisions.

## Cache invalidation is a distributed systems problem

DevFeed: [Cache invalidation is a distributed systems problem](<https://devfeed.tech/articles/cache-invalidation-is-a-distributed-systems-problem-in-a-convenience-costume-39604.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/52-cache-invalidation-distributed-problem/>)

Author: hello@ankit-rana.com

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

Content type: tutorial

Language: en

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

Topics: [Cache](<https://devfeed.tech/topics/cache.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [race-conditions](<https://devfeed.tech/tags/race-conditions.md>), [redis](<https://devfeed.tech/tags/redis.md>), [ttl](<https://devfeed.tech/tags/ttl.md>)

### AI overview

Cache invalidation coordinates updates between a database and a cache without a shared transaction. The article explains how operation ordering can let a concurrent reader repopulate stale data and recommends writing to the database before invalidating the cache, followed by a second invalidation to close the remaining race.

### Source excerpt

A cache and a database are two stores that must agree, which makes every invalidation a distributed transaction without a coordinator. The ordering matters more than the mechanism: invalidating before the database write leaves a window where a concurrent reader repopulates the cache with the old value and it stays wrong until the TTL expires. Deleting the key rather than writing the new value removes a whole class of ordering bug, because two concurrent deletes commute and two concurrent writes do not.

## Jetpack: Consensus Made Generally Fast (OSDI '26)

DevFeed: [Jetpack: Consensus Made Generally Fast (OSDI '26)](<https://devfeed.tech/articles/jetpack-consensus-made-generally-fast-osdi-26-41858.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/09/jetpack-consensus-made-generally-fast.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-09-12T05:36:27Z

Content type: article

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [Latency](<https://devfeed.tech/topics/latency.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Replication](<https://devfeed.tech/topics/replication.md>), [Raft](<https://devfeed.tech/topics/raft.md>), [protocols](<https://devfeed.tech/topics/protocols.md>), [parallel](<https://devfeed.tech/topics/parallel.md>), [ordering](<https://devfeed.tech/topics/ordering.md>), [execution](<https://devfeed.tech/topics/execution.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [distributed-consensus](<https://devfeed.tech/tags/distributed-consensus.md>), [execution](<https://devfeed.tech/tags/execution.md>), [latency](<https://devfeed.tech/tags/latency.md>), [livediscussion](<https://devfeed.tech/tags/livediscussion.md>), [network](<https://devfeed.tech/tags/network.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [paxos](<https://devfeed.tech/tags/paxos.md>), [raft](<https://devfeed.tech/tags/raft.md>), [replication](<https://devfeed.tech/tags/replication.md>)

### AI overview

This paper review examines Jetpack, an add-on framework for existing leader-based consensus protocols. Jetpack runs a 1-RTT fast path alongside the original 2-RTT path, potentially reducing WAN commit latency, but its dual-log design duplicates network and replica processing and separates fast commitment from state-machine execution ordering.

### Source excerpt

Aleksey and I are back to reading papers live. This paper, Jetpack(OSDI '26), attempts building a universal 1-RTT fast-path framework that bolts onto existing leader-based consensus protocols with minimal modification. Why would we want this? Classic consensus protocols like Raft, Paxos, or Zab require two round-trip times (2 RTT) to commit a command: one RTT from client to leader, and another to replicate across followers. The extra RTT matters a lot for WAN deployments, so fast-path protocols (such as Fast Paxos, EPaxos, or SwiftPaxos) reduce this to 1 RTT by bypassing leader serialization, but unfortunately they tightly couple the fast path to the core protocol design. Production systems cannot easily swap out their battle-tested bespoke consensus engines, but if there was an add on that helped with latency especially in WAN deployments, that would be useful. The good news is that Jetpack is truly an add-on portable deal. It provides a shim layer that runs two execution paths in parallel: a 1-RTT fast path and the original 2-RTT consensus path. When a client issues a command, it broadcasts the request concurrently to both paths. The fast path checks for key conflicts, and if none exist and a supermajority quorum ($\sim 3/4$ of nodes) issues a promise, this enables the command to fast-commit in 1 RTT. To guarantee agreement, original path proposers promise not to propose conflicting commands ahead of fast-committed ones. The bad news is that this design gets wasteful due to keeping two distinct logs (the fast-path log and the original-path log). The original consensus engine runs its full replication cycle in the background, ignoring the fast path replication of commands (because it is completely oblivious to the fast path replication in the name of bolt-on portability). So these commands travel in the network twice, and replicas process commands twice, introducing redundant work and extra CPU/network overhead. This dual-log architecture also creates a bigger gap

## A quick overview of atomics in C

DevFeed: [A quick overview of atomics in C](<https://devfeed.tech/articles/a-quick-overview-of-atomics-in-c-29428.md>)

Original publisher: [Read original article](<https://lemire.me/blog/2026/09/09/a-quick-overview-of-atomics-in-c/>)

Author: Daniel Lemire

Published: 2026-09-09T20:41:53Z

Content type: tutorial

Language: en

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

Topics: [C](<https://devfeed.tech/topics/c.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [atomics](<https://devfeed.tech/tags/atomics.md>), [c](<https://devfeed.tech/tags/c.md>), [join](<https://devfeed.tech/tags/join.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [posix](<https://devfeed.tech/tags/posix.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [systems](<https://devfeed.tech/tags/systems.md>), [thread](<https://devfeed.tech/tags/thread.md>), [threads](<https://devfeed.tech/tags/threads.md>)

### AI overview

This tutorial introduces atomics in C, explaining data races on shared non-atomic variables, atomic accesses, instruction reordering, and memory-ordering models including relaxed, release, and acquire semantics. It also discusses C11 threads and platform support limitations.

### Source excerpt

If you write in C, by default, you use a single thread. Extra cores do not help until you create more threads. However, if you include the header <threads.h>, you can pass a function to thrd_create, and wait for it with thrd_join. #include <threads.h> #include <stdio.h> int worker(void *arg) { printf("hello from thread %d\n", *(int ... Continue reading A quick overview of atomics in C

## A humorous roundup of software and website errors involving Google, Microsoft, and the New Mexico DOT

DevFeed: [A humorous roundup of software and website errors involving Google, Microsoft, and the New Mexico DOT](<https://devfeed.tech/articles/error-d-hello-new-mexico-28509.md>)

Original publisher: [Read original article](<https://thedailywtf.com/articles/hello-new-mexico>)

Author: Lyle Seaman

Published: 2026-08-28T06:30:00Z

Content type: opinion

Language: en

Sources: [The Daily WTF](<https://devfeed.tech/sources/the-daily-wtf.md>)

Topics: [ordering](<https://devfeed.tech/topics/ordering.md>), [Google](<https://devfeed.tech/topics/google.md>), [Microsoft](<https://devfeed.tech/topics/microsoft.md>), [Website](<https://devfeed.tech/topics/website.md>)

Tags: [error-d](<https://devfeed.tech/tags/error-d.md>), [google](<https://devfeed.tech/tags/google.md>), [microsoft](<https://devfeed.tech/tags/microsoft.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [web](<https://devfeed.tech/tags/web.md>), [website](<https://devfeed.tech/tags/website.md>)

### AI overview

This opinion piece presents a humorous roundup of software and website mistakes. It discusses an ordering error, Google's apparent counting mistake, Microsoft Outlook account and contact-form problems, a pricing-unit misunderstanding, and a New Mexico DOT website.

### Source excerpt

Peter G. shared with us yet another ordering bungled example of. "Should really say "please engage in an Easter egg hunt to find your language"." "Google can't count" claimed Peter S.. It adds up. "Yet another proof that 0=1, this time from Google." "Thanks, Microsoft" groused Ivan "Ever since Microsoft ate university e-mail services worldwide and became responsible for major free software mailing lists, quality of service has been steadily dropping. In order to report delivery problems to Outlook, you need a Microsoft account. You're prevented from creating it at first because of "suspicious activity". Once you're in, the contact address is pre-filled for you with an invalid email. Once you fix that in the web developer toolbar, fuck you anyway! I think the form isn't actually expected to work; the fact that the request was submitted is an error. The only thing missing from the experience is the "beware of the leopard" sign." "Mango Math" needs a bit of money math for the rest of the world to understand. Michael R. muttered "I will buy it by the slice then." The joke here is on the tip of my tongue. Explainer: the new pence is one hundredth of the decimal pound. No shillings no more, decreps! At that ratio, 3p per slice of cheesecake would indeed be far less dear than four pounds for the whole thing, barring translucent slices. Alas, the reality is simply the boring fact that the price is 3p per gram. Not as funny but I'm chuckling imagining Michael's transparent serving of diet cheesecake. I'll leave it up to you to decide if a gram really counts as an "item". Clint clucked "Got this email from Bigbadtoystore. Lots of links available for preorder!" I think the talented website builders behind the New Mexico DOT have been busy. [Advertisement] Picking up NuGet is easy. Getting good at it takes time. Download our guide to learn the best practice of NuGet for the Enterprise.

## Why Code Removal May Be Preferable to Scheduling for Performance Remediation

DevFeed: [Why Code Removal May Be Preferable to Scheduling for Performance Remediation](<https://devfeed.tech/articles/the-wicked-reason-removing-code-beats-better-scheduling-26567.md>)

Original publisher: [Read original article](<https://infrequently.org/2026/08/notes-on-performance-remediation-strategies/>)

Author: Alex Russell

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

Content type: opinion

Language: en

Sources: [Alex Russell](<https://devfeed.tech/sources/alex-russell.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [ordering](<https://devfeed.tech/topics/ordering.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [performance](<https://devfeed.tech/tags/performance.md>), [webdev](<https://devfeed.tech/tags/webdev.md>)

### AI overview

An opinion article arguing that removing code can be a more reliable performance-remediation strategy than reordering or deferring work. It says both approaches require understanding page behavior, while scheduling changes can increase validation, coordination, bandwidth, and main-thread performance risks.

### Source excerpt

My colleague Marko Ilić has published an insightful piece on how to schedule work on the critical path, and I recommend reading it before proceeding here. Contents Elimination vs. Scheduling: An Organisational Perspective What's Good for the Goose... "Preloading" as Scheduling Scheduling Is For Closers General-Purpose Advice ...and welcome back. As you likely anticipated, Marko's beautifully presented post kicked off healthy discussions around the office. Since we almost always see eye-to-eye, it seemed interesting to surface some of that discussion here. With his permission, what follows are expanded versions of some points I posed in reply. Elimination vs. Scheduling: An Organisational Perspective There's no daylight between our positions on code reduction: sending and running less is always ideal. Where we differ, perhaps, is the priority teams should assign to scheduling vs. code removal in their performance remediation efforts. Contra Marko, I posit that reordering can almost never be assumed to be cheaper or easier. While it may be hard to remove code, my view is that it is generally not harder than re-ordering in most codebases. Why? The primary cost of both code removal and scheduling interventions is the investment to deeply understand page behaviour. This presents a narrative challenge to the proposition that scheduling is an easier fix, as both approaches share the largest cost. At the team level, the consequences of restructuring are harder to reason about than direct removal, reducing potential upside and increasing validation costs. Bytes that are only deferred still contend for bandwidth, potentially delaying above-the-fold resources in ways that only become visible in the tail of the connection quality curve. Worse, late-fetched JS resources generate heavy "thuds" when residual allocations from background compilation arrive on the main thread. These stalls show up in INP data, but can be maddening to track down due to their stochastic relationship wi

## Keleusma Research Spike: Blocking Frequency as the Ordering Principle for Instruction-Set Coverage

DevFeed: [Keleusma Research Spike: Blocking Frequency as the Ordering Principle for Instruction-Set Coverage](<https://devfeed.tech/articles/keleusma-research-spike-blocking-frequency-as-the-ordering-principle-for-instruction-set-coverage-39752.md>)

Original publisher: [Read original article](<https://sgeos.github.io/engineering/compilers/verification/2026/08/06/native_lowering_coverage.html>)

Author: Brendan Sechter

Published: 2026-08-06T09:00:00Z

Content type: article

Language: en

Sources: [Brendan A R Sechter's Development Blog](<https://devfeed.tech/sources/brendan-a-r-sechter-s-development-blog.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [Code generation](<https://devfeed.tech/topics/code-generation.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [measurement](<https://devfeed.tech/tags/measurement.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [research](<https://devfeed.tech/tags/research.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

This case study examines how blocking frequency can guide the order of instruction implementation in Keleusma's compiler backend. It contrasts instruction-level coverage with whole-program compilability and describes a small measurement tool that exposed a flawed implementation plan.

### Source excerpt

A compiler was 87 percent finished. It could not compile two thirds of the programs it was for. Both numbers are correct. The first counts individual instructions the compiler knew how to translate. The second counts whole programs that would actually go through. The gap between them is what this article is about, and the reason it exists is simple enough to state in one sentence. A program needs every instruction it uses, not most of them. One missing instruction out of a hundred stops the whole thing, exactly as one missing link stops a chain. That gap then destroyed a carefully reasoned plan. One working session before the measurement was taken, the author of this article had formally recommended what the next piece of work should be. The reasoning had no invalid step in it. The measurement showed the recommendation to be worth nothing at all, because the thing it would have unblocked does not occur even once in any program the compiler is meant to serve. The instrument that established this took about twenty minutes to build and two seconds to run. The article reports that, and then reports four errors made while writing it, all four of which ran in the direction of a more striking result, and one of which was committed inside the paragraph warning against the other three. What this is a case study of The setting is compiler engineering, and a reader who has never written a compiler can follow the argument, because the shape of the problem is not specific to compilers. The concrete project is Keleusma, whose compiler until now has emitted bytecode for a virtual machine, as described in the self-hosting strategy and its getting-started article. Native code generation is the step after that one, and it is where the ordering question first became expensive enough to measure. The lineage of the design sits in the stream-based compilers series and in the self-hosted silicon compiler. None of that background is needed to follow what follows, and the measurement stands

## A 13th-Century Enumeration Algorithm, Ignored for 700 Years

DevFeed: [A 13th-Century Enumeration Algorithm, Ignored for 700 Years](<https://devfeed.tech/articles/a-13th-century-enumeration-algorithm-ignored-for-700-years-37561.md>)

Original publisher: [Read original article](<https://blog.klipse.tech/aboulafia/2026/07/06/a-13th-century-enumeration-algorithm-ignored-for-700-years.html>)

Author: Yehonathan Sharvit

Published: 2026-07-06T07:00:00Z

Content type: article

Language: en

Sources: [Klipse](<https://devfeed.tech/sources/klipse.md>)

Topics: [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [ordering](<https://devfeed.tech/topics/ordering.md>), [structure](<https://devfeed.tech/topics/structure.md>)

Tags: [aboulafia](<https://devfeed.tech/tags/aboulafia.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [kabbalah](<https://devfeed.tech/tags/kabbalah.md>), [math](<https://devfeed.tech/tags/math.md>), [order](<https://devfeed.tech/tags/order.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [permutations](<https://devfeed.tech/tags/permutations.md>)

### AI overview

The article examines a systematic method for enumerating permutations described by the 13th-century Kabbalist Abraham Aboulafia in his account of Tserouf. It explains rules for ordering three-letter permutations and a rotation-based method for extending the ordering to longer words.

### Source excerpt

Aboulafia's Tserouf - Part 1 of 4 Next: An elegant formulation, inspired by Bill Gates ->

## How Asynchronous Systems Trade Execution Order for Scale and Availability

DevFeed: [How Asynchronous Systems Trade Execution Order for Scale and Availability](<https://devfeed.tech/articles/async-systems-scale-your-system-and-your-problems-17948.md>)

Original publisher: [Read original article](<https://newsletter.systemdesignclassroom.com/p/async-systems-scale-your-system-and-your-problems>)

Author: Raul Junco

Published: 2026-03-28T13:04:17Z

Content type: article

Language: en

Sources: [System Design Classroom](<https://devfeed.tech/sources/system-design-classroom.md>)

Topics: [systems](<https://devfeed.tech/topics/systems.md>), [event driven](<https://devfeed.tech/topics/event-driven.md>), [Availability](<https://devfeed.tech/topics/availability.md>)

Tags: [async](<https://devfeed.tech/tags/async.md>), [availability](<https://devfeed.tech/tags/availability.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>), [queue](<https://devfeed.tech/tags/queue.md>), [scale](<https://devfeed.tech/tags/scale.md>), [state](<https://devfeed.tech/tags/state.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

The article explains how asynchronous systems improve scale, throughput, and availability by processing work in parallel, while making execution order and consistency harder to control. Queues, retries, and parallel consumers can reorder related events, producing incorrect final state even when every component succeeds.

### Source excerpt

Many developers only realize it after consistency breaks.

## Improving Embedding-Based Candidate Generation for Recommender Systems with a Two-Tower Model

DevFeed: [Improving Embedding-Based Candidate Generation for Recommender Systems with a Two-Tower Model](<https://devfeed.tech/articles/improving-embedding-based-candidate-generation-for-recommender-systems-with-a-two-tower-model-22610.md>)

Original publisher: [Read original article](<https://medium.com/glassdoor-engineering/improving-embedding-based-candidate-generation-for-recommender-systems-with-a-two-tower-model-c222123beb7f?source=rss----288d984af747---4>)

Author: Ahmad Khan

Published: 2026-03-18T21:04:58Z

Content type: article

Language: en

Sources: [Glassdoor Engineering](<https://devfeed.tech/sources/glassdoor-engineering.md>)

Topics: [recommendation systems](<https://devfeed.tech/topics/recommendation-systems.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [Embeddings](<https://devfeed.tech/topics/embeddings.md>), [Neural Network](<https://devfeed.tech/topics/neural-network.md>), [data](<https://devfeed.tech/topics/data.md>), [ordering](<https://devfeed.tech/topics/ordering.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [data](<https://devfeed.tech/tags/data.md>), [embedding](<https://devfeed.tech/tags/embedding.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [model-training](<https://devfeed.tech/tags/model-training.md>), [neural-network](<https://devfeed.tech/tags/neural-network.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [ranking](<https://devfeed.tech/tags/ranking.md>), [recommender-systems](<https://devfeed.tech/tags/recommender-systems.md>), [self-supervised-learning](<https://devfeed.tech/tags/self-supervised-learning.md>), [two-tower-model](<https://devfeed.tech/tags/two-tower-model.md>)

### AI overview

Glassdoor describes a two-tower neural network for candidate generation in its Community feed recommendation system. The model learns user and post embeddings from interaction data to retrieve potentially relevant posts before filtering, ranking, and ordering.

### Source excerpt

Overview At Glassdoor (part of Indeed), millions of professionals come to learn about workplaces, ask career questions, and share experiences through our Community platform. When users open the Community Home Feed, they expect to see posts that are relevant to their interests, industry, and career stage. However, generating that feed is not a simple task. At any moment, thousands of new posts across hundreds of community feeds compete for attention. From discussions about interview experiences to workplace culture questions and industry advice, the platform contains a diverse and constantly evolving stream of content. The challenge is to quickly identify which of these posts are most relevant for each user. To address this problem, we built a multi-stage machine learning recommendation system that efficiently sources, filters, and ranks posts before they appear in the user's feed. In a previous post, Inside Glassdoor's Multi-Stage Recommendation System, we described the architecture of this system and how the different stages work together to deliver personalized content. Snapshot of the Glassdoor Community Home Feed At a high level, the system consists of four stages: Candidate Generation -- retrieves a large set of potentially relevant posts Filtering -- removes posts that are undesirable, duplicated, or already seen Ranking -- predicts which posts a user is most likely to engage with Ordering -- applies heuristics to maintain diversity and freshness in the feed Each stage progressively narrows the set of posts until only the most relevant posts remain. 4 Stage ML RecSys Design In this blog post, we focus on the Candidate Generation stage, which is responsible for retrieving an initial pool of potentially relevant posts from a very large pool of posts across many different feeds. For Candidate Generation, we developed a Two-Tower Neural Network Model that learns embeddings for users and posts based on real interaction data. In the rest of this blog post, we will walk

## netlab Graphs with Multi-Access Links

DevFeed: [netlab Graphs with Multi-Access Links](<https://devfeed.tech/articles/netlab-graphs-with-multi-access-links-11347.md>)

Original publisher: [Read original article](<https://blog.ipspace.net/2026/03/netlab-graphs-multiaccess/>)

Published: 2026-03-16T07:03:00Z

Content type: tutorial

Language: en

Sources: [ipSpace.net blog](<https://devfeed.tech/sources/ipspace-net-blog.md>)

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

Tags: [devices](<https://devfeed.tech/tags/devices.md>), [graph](<https://devfeed.tech/tags/graph.md>), [graphs](<https://devfeed.tech/tags/graphs.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [netlab](<https://devfeed.tech/tags/netlab.md>), [node](<https://devfeed.tech/tags/node.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [router](<https://devfeed.tech/tags/router.md>)

### AI overview

This tutorial explains how to improve GraphViz topology graphs generated from netlab descriptions of multi-access links. It covers graph.rank and graph.linkorder, including a current limitation that leaves setting graph.linkorder on host interfaces as the practical solution.

### Source excerpt

A netlab user wanted to create a nice-looking topology graph from a simple topology connecting a few devices to a broadcast (multi-access) link. I don't have his exact topology, so we'll use this one (skipping the details like setting device types) nodes: [ r1, r2, h1, h2 ] links: - r1-r2 - interfaces: [ r1, r2, h1, h2 ] This is what GraphViz generates based on netlab's description of the lab topology: Read more ...

## McDonald's Pilots Real-Time Automation for Ice Cream Product Availability

DevFeed: [McDonald's Pilots Real-Time Automation for Ice Cream Product Availability](<https://devfeed.tech/articles/from-ideation-to-automation-the-scoop-on-outages-23978.md>)

Original publisher: [Read original article](<https://medium.com/mcdonalds-technical-blog/from-ideation-to-automation-the-scoop-on-outages-1ad0eab5cee1?source=rss----3bac42476d27---4>)

Author: Global Technology

Published: 2026-03-12T16:13:47Z

Content type: article

Language: en

Sources: [McDonald's Technical Blog - Medium](<https://devfeed.tech/sources/mcdonald-s-technical-blog-medium.md>)

Topics: [Automation](<https://devfeed.tech/topics/automation.md>), [Availability](<https://devfeed.tech/topics/availability.md>), [Internet of things](<https://devfeed.tech/topics/iot.md>), [ordering](<https://devfeed.tech/topics/ordering.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [automation](<https://devfeed.tech/tags/automation.md>), [availability](<https://devfeed.tech/tags/availability.md>), [customer-experience](<https://devfeed.tech/tags/customer-experience.md>), [digital-transformation](<https://devfeed.tech/tags/digital-transformation.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [internet-of-things](<https://devfeed.tech/tags/internet-of-things.md>), [iot](<https://devfeed.tech/tags/iot.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [outages](<https://devfeed.tech/tags/outages.md>), [technology](<https://devfeed.tech/tags/technology.md>)

### AI overview

McDonald's piloted a real-time automation pipeline that connects ice cream machines to Sesame POS. At a Global Tech pilot restaurant, the system automatically removes products during machine downtime and re-enables them when the machine becomes operational, updating kiosks, mobile apps, and POS systems. The solution has not yet been rolled out broadly.

### Source excerpt

A process that once required a multi-click manual process is now fully automated in real time, with a Global Tech pilot restaurant testing the solution to boost efficiency and enhance the customer experience. by: Chloe Tominac, Manager, Engineering Tech Lead & Lauren Adamonis, Manager, Engineering Tech Lead Quick Bytes: Crew members had to manually mark ice cream items unavailable through a multi-click process, and later use the same process to restore items, which often led to missed updates and customer frustration A real-time automation pipeline was piloted to connect the ice cream machine to Sesame POS, instantly updating product availability The solution launched in McDonald's Global Tech pilot restaurant, improving restaurant efficiency and ensuring customers see accurate menus across all ordering channels In restaurant operations, every second counts -- especially when equipment goes offline. That's why McDonald's tech teams set out to automate the ice cream product outage process, transforming a manual workflow into a seamless, real-time system as part of our ongoing digital transformation. To explore how this could work in a live environment, we put the solution to the test in one of our Global Tech pilot restaurants. This pilot is helping us learn how real-time equipment data can improve restaurant efficiency and customer experience. While it's not yet rolled out broadly, the insights from this test are shaping how we think about scaling automation across restaurant operations. Previously, a multi-click process was required to take ice cream items off the menu during machine downtime. Without automatic recovery, items often remained unavailable even after the machine was back online until a crew member restored them, resulting in customers hearing that the ice cream machine was "broken." Automation now ensures menu items are immediately re-enabled as soon as the machine is operational. Now, thanks to a collaboration between the Internet of Things (IoT) team

## Keycloak 26.4.5 released

DevFeed: [Keycloak 26.4.5 released](<https://devfeed.tech/articles/keycloak-26-4-5-released-31736.md>)

Original publisher: [Read original article](<https://www.keycloak.org/2025/11/keycloak-2645-released>)

Author: Keycloak Team

Published: 2025-11-12T00:00:00Z

Content type: release

Language: en

Sources: [Keycloak Blog](<https://devfeed.tech/sources/keycloak-blog.md>)

Topics: [Keycloak](<https://devfeed.tech/topics/keycloak.md>), [changelog](<https://devfeed.tech/topics/changelog.md>)

Tags: [authorization](<https://devfeed.tech/tags/authorization.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [ci](<https://devfeed.tech/tags/ci.md>), [docs](<https://devfeed.tech/tags/docs.md>), [download](<https://devfeed.tech/tags/download.md>), [email](<https://devfeed.tech/tags/email.md>), [idm](<https://devfeed.tech/tags/idm.md>), [import](<https://devfeed.tech/tags/import.md>), [jpa](<https://devfeed.tech/tags/jpa.md>), [kerberos](<https://devfeed.tech/tags/kerberos.md>), [keycloak](<https://devfeed.tech/tags/keycloak.md>), [keycloak-release](<https://devfeed.tech/tags/keycloak-release.md>), [ldap](<https://devfeed.tech/tags/ldap.md>), [migration-guide](<https://devfeed.tech/tags/migration-guide.md>), [openid-connect](<https://devfeed.tech/tags/openid-connect.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [quarkus](<https://devfeed.tech/tags/quarkus.md>), [release](<https://devfeed.tech/tags/release.md>), [saml](<https://devfeed.tech/tags/saml.md>), [sso](<https://devfeed.tech/tags/sso.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

Keycloak 26.4.5 was released on November 12, 2025. The release page links to downloads and a migration guide and lists resolved issues involving tests, documentation, JPA, email persistence, database migration, authorization policies, attribute ordering, Quarkus builds, URL normalization, and the Admin Console.

### Source excerpt

To download the release go to Keycloak downloads. Upgrading Before upgrading refer to the migration guide for a complete list of changes. All resolved issues Bugs #42601 Flaky test: org.keycloak.testsuite.broker.KcOidcBrokerTest#testPostBrokerLoginFlowWithOTP ci #43212 Document missing artifact dependency for UserStoragePrivateUtil docs #43564 Invalid liquibase check sum for jpa-changelog-2.5.0.xml core #43718 Email Not Persisted During Registration When "Email as Username" is Enabled and User Edit Permission is Disabled user-profile #43793 import does not seem to run db migration import-export #43883 Creating group policy on a client uses "manage-clients" role if FGAP V1 is disabled authorization-services #44010 Ordering attributes will unset the unmanaged attribute policy user-profile #44031 Can't build keycloak 26.4.4 with quarkus.launch.rebuild=true dist/quarkus #44056 Allow only normalized URLs in requests caused a regression in view authz permission details in Admin Consol admin/ui #44117 DockerClientTest failure testsuite

## Inside Glassdoor's Multi-Stage Recommendation System

DevFeed: [Inside Glassdoor's Multi-Stage Recommendation System](<https://devfeed.tech/articles/inside-glassdoor-s-multi-stage-recommendation-system-22611.md>)

Original publisher: [Read original article](<https://medium.com/glassdoor-engineering/inside-glassdoors-multi-stage-recommendation-system-cee58b52a75a?source=rss----288d984af747---4>)

Author: Prateek Shekhar

Published: 2025-08-12T19:37:39Z

Content type: article

Language: en

Sources: [Glassdoor Engineering](<https://devfeed.tech/sources/glassdoor-engineering.md>)

Topics: [recommendation systems](<https://devfeed.tech/topics/recommendation-systems.md>), [recommendations](<https://devfeed.tech/topics/recommendations.md>), [personalization](<https://devfeed.tech/topics/personalization.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [ordering](<https://devfeed.tech/topics/ordering.md>), [ann](<https://devfeed.tech/topics/ann.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [ann](<https://devfeed.tech/tags/ann.md>), [glassdoor](<https://devfeed.tech/tags/glassdoor.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [personalization](<https://devfeed.tech/tags/personalization.md>), [recommendation-system](<https://devfeed.tech/tags/recommendation-system.md>), [recommendation-systems](<https://devfeed.tech/tags/recommendation-systems.md>), [recommender-systems](<https://devfeed.tech/tags/recommender-systems.md>)

### AI overview

This article gives a high-level overview of Glassdoor's hybrid, multi-stage recommendation system. It describes how the system uses user behavior, similar-user behavior, and item features to produce personalized recommendations for the Community Feed, Email, and Push notifications, with stages including candidate generation, filtering, scoring, and ordering.

### Source excerpt

Introduction: Recommendation systems are central to modern digital platforms, delivering personalized content by intelligently analyzing user behavior and preferences through advanced algorithms. Widely used in e-commerce, streaming services, social media, and online learning, they drive user satisfaction, engagement, and retention while supporting business growth. Typically, these systems operate using one or more of the following approaches: Collaborative Filtering: This approach examines user behavior by comparing how users interact with items. It identifies patterns by analyzing similar user actions. For example, if two users have watched or purchased similar items, the system will recommend those same items to other users with similar behavior. Content-Based Filtering: In this approach, the system analyzes the characteristics of the items themselves, such as text, images, or other features. It recommends items that have features similar to those a user has previously liked. For example, if a user enjoyed books with specific keywords, the system will suggest books with those exact keywords. Hybrid Approach: This approach combines collaborative and content-based filtering to enhance personalization and accuracy. It utilizes user behavior patterns in conjunction with item features, offering more personalized and accurate recommendations. At Glassdoor, our Community Feed, Email, and Push notifications are powered by a recommendation system that follows a hybrid approach. It analyzes individual users' behavior, such as posts, comments, and reactions, as well as the behavior of similar users, to deliver tailored, personalized recommendations. This post presents a high-level overview of the multi-stage architecture behind our system, highlighting candidate generation, filtering, scoring, ordering, and supporting infrastructure. Glassdoor's Recommendation System ArchitectureFigure 1: Glassdoor's Recommendation System Architecture Glassdoor's Recommendation System follo

## Efficient Distributed Unique Timestamp Identifier Generation

DevFeed: [Efficient Distributed Unique Timestamp Identifier Generation](<https://devfeed.tech/articles/efficient-distributed-unique-timestamp-identifier-generation-30742.md>)

Original publisher: [Read original article](<http://blog.vanillajava.blog/2024/12/efficient-distributed-unique-timestamp.html>)

Author: Peter Lawrey (noreply@blogger.com)

Published: 2024-12-08T19:51:00Z

Content type: tutorial

Language: en

Sources: [Vanilla Java](<https://devfeed.tech/sources/vanilla-java.md>)

Topics: [identifier](<https://devfeed.tech/topics/identifier.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [ordering](<https://devfeed.tech/topics/ordering.md>), [Latency](<https://devfeed.tech/topics/latency.md>)

Tags: [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [identifier](<https://devfeed.tech/tags/identifier.md>), [latency](<https://devfeed.tech/tags/latency.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [performance](<https://devfeed.tech/tags/performance.md>), [precision](<https://devfeed.tech/tags/precision.md>), [unique](<https://devfeed.tech/tags/unique.md>)

### AI overview

The article presents a distributed identifier scheme that embeds a host identifier into a nanosecond-resolution timestamp. It describes the resulting 64-bit identifiers as globally unique, human-readable, chronologically sortable, and suitable for high-concurrency, latency-sensitive systems.

### Source excerpt

Distributed unique timestamp identifiers provide a powerful means of generating globally unique, human-readable 64-bit values at sub-microsecond speeds. By embedding a host identifier directly into a nanosecond-resolution timestamp, you gain a simple, chronologically sortable, and intuitive scheme for correlating events across multiple hosts. This approach offers significant benefits in latency-sensitive systems where even small delays can become expensive at scale. Introduction In a world of horizontally scaled microservices, ensuring that each event or message receives a unique identifier across multiple machines can be challenging. Traditional approaches often rely on UUIDs, which--while easy to use--lack intuitive readability and can be relatively expensive to generate in ultra-low-latency scenarios. Our solution builds upon nanosecond-resolution timestamps combined with a host identifier embedded directly into the lower-order digits of the timestamp. This technique, inspired by previous work on system-wide unique nanosecond timestamps, creates identifiers that are compact, human-interpretable, and extremely fast to produce. In essence, we treat time itself as the source of uniqueness. By carefully structuring the timestamp and assigning a unique hostId per machine (or per logical partition), we can scale to produce up to one billion unique 64-bit identifiers per second. These identifiers repeat only after centuries, making them suitable for long-running systems and distributed architectures that demand both precision and high performance. Concurrent identifier generation in a distributed system In distributed environments, colliding identifiers can lead to data corruption, misrouted requests, or difficulty in debugging. Although UUIDs solve uniqueness issues, they do not inherently convey temporal ordering or machine origin. More subtle forms of identifiers, such as database sequence numbers or custom counters, often need to be more convenient when synchronising

## How I Finally Memorized Modifier Ordering in Compose

DevFeed: [How I Finally Memorized Modifier Ordering in Compose](<https://devfeed.tech/articles/how-i-finally-memorized-modifier-ordering-in-compose-27080.md>)

Original publisher: [Read original article](<https://zsmb.co/remembering-modifier-order/>)

Author: Márton Braun

Published: 2024-06-04T09:00:00Z

Content type: tutorial

Language: en

Sources: [zsmb.co](<https://devfeed.tech/sources/zsmb-co.md>)

Topics: [ordering](<https://devfeed.tech/topics/ordering.md>), [Compose](<https://devfeed.tech/topics/compose.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [ui](<https://devfeed.tech/topics/ui.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [compose](<https://devfeed.tech/tags/compose.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [marton-braun](<https://devfeed.tech/tags/marton-braun.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [ui](<https://devfeed.tech/tags/ui.md>), [zsmb](<https://devfeed.tech/tags/zsmb.md>), [zsmb-co](<https://devfeed.tech/tags/zsmb-co.md>), [zsmb13](<https://devfeed.tech/tags/zsmb13.md>), [zsmbco](<https://devfeed.tech/tags/zsmbco.md>)

### AI overview

A tutorial explains how to remember modifier ordering in Jetpack Compose. It connects component APIs that accept a Modifier parameter with the way modifiers are applied, concluding that modifiers are applied last-to-first and inside-to-outside.

### Source excerpt

For the longest time, I proudly had no idea of how Modifier ordering works, and would just guess and then guess again when something didn't look quite right. Here's how I finally ended up remembering how the ordering works.

## Getting Top 1 Values Per Group in Oracle

DevFeed: [Getting Top 1 Values Per Group in Oracle](<https://devfeed.tech/articles/getting-top-1-values-per-group-in-oracle-28939.md>)

Original publisher: [Read original article](<https://blog.jooq.org/getting-top-1-values-per-group-in-oracle/>)

Author: lukaseder

Published: 2024-03-01T09:55:41Z

Content type: tutorial

Language: en

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

Topics: [ordering](<https://devfeed.tech/topics/ordering.md>), [JSON](<https://devfeed.tech/topics/json.md>)

Tags: [aggregate-functions](<https://devfeed.tech/tags/aggregate-functions.md>), [any-value](<https://devfeed.tech/tags/any-value.md>), [function](<https://devfeed.tech/tags/function.md>), [json](<https://devfeed.tech/tags/json.md>), [keep](<https://devfeed.tech/tags/keep.md>), [oracle](<https://devfeed.tech/tags/oracle.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [sql](<https://devfeed.tech/tags/sql.md>), [syntax](<https://devfeed.tech/tags/syntax.md>), [top-1-per-category](<https://devfeed.tech/tags/top-1-per-category.md>), [type-safety](<https://devfeed.tech/tags/type-safety.md>), [types](<https://devfeed.tech/tags/types.md>)

### AI overview

A tutorial on selecting the top one or top n values per group in Oracle. It discusses ordering and ties, repetition when projecting multiple columns, Oracle object types and ANY_VALUE in Oracle 21c, and JSON as an alternative workaround.

### Source excerpt

I've blogged about generic ways of getting top 1 or top n per category queries before on this blog. An Oracle specific version in that post used the arcane KEEP syntax: This is a bit difficult to read when you see it for the first time. Think of it as a complicated way to say ... Continue reading Getting Top 1 Values Per Group in Oracle ->

## To choreograph or orchestrate your saga, that is the question

DevFeed: [To choreograph or orchestrate your saga, that is the question](<https://devfeed.tech/articles/to-choreograph-or-orchestrate-your-saga-that-is-the-question-36076.md>)

Original publisher: [Read original article](<https://temporal.io/blog/to-choreograph-or-orchestrate-your-saga-that-is-the-question>)

Author: Emily Fortuna

Published: 2023-07-13T15:30:00Z

Content type: article

Language: en

Sources: [Temporal Blog](<https://devfeed.tech/sources/temporal-blog.md>)

Topics: [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [microservices architecture](<https://devfeed.tech/topics/microservices-architecture.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [business logic](<https://devfeed.tech/topics/business-logic.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [backend](<https://devfeed.tech/tags/backend.md>), [debug](<https://devfeed.tech/tags/debug.md>), [decoupling](<https://devfeed.tech/tags/decoupling.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [microservices-architecture](<https://devfeed.tech/tags/microservices-architecture.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [ordering](<https://devfeed.tech/tags/ordering.md>)

### AI overview

This article explains the saga pattern for tasks that span microservice boundaries and compares choreography with orchestration. It describes how choreography uses message passing and local service knowledge, while distributed ordering requirements can make control flow harder to understand and debug.

### Source excerpt

An explanation of orchestration and choreography of microservices, and how Temporal works under the hood. Find out how and why.

## Emulating Window Functions in MySQL 5.7

DevFeed: [Emulating Window Functions in MySQL 5.7](<https://devfeed.tech/articles/emulating-window-functions-in-mysql-5-7-28938.md>)

Original publisher: [Read original article](<https://blog.jooq.org/emulating-window-functions-in-mysql-5-7/>)

Author: lukaseder

Published: 2023-01-20T11:07:00Z

Content type: tutorial

Language: en

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

Topics: [MySQL](<https://devfeed.tech/topics/mysql.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [Databases](<https://devfeed.tech/topics/databases.md>)

Tags: [dense-rank](<https://devfeed.tech/tags/dense-rank.md>), [deprecated](<https://devfeed.tech/tags/deprecated.md>), [emulations](<https://devfeed.tech/tags/emulations.md>), [local-variables](<https://devfeed.tech/tags/local-variables.md>), [mysql](<https://devfeed.tech/tags/mysql.md>), [mysql-5-7](<https://devfeed.tech/tags/mysql-5-7.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [rank](<https://devfeed.tech/tags/rank.md>), [row-number](<https://devfeed.tech/tags/row-number.md>), [sql](<https://devfeed.tech/tags/sql.md>), [window-functions](<https://devfeed.tech/tags/window-functions.md>)

### AI overview

This tutorial explains how to emulate window functions in MySQL 5.7 using user variables. It warns that the technique depends on incidental evaluation order, can break when query execution changes, and is deprecated in MySQL 8.x.

### Source excerpt

One of MySQL 8's biggest improvements is the support of window functions. As I always said in conferences, there's SQL before window functions and SQL after window functions. Once you start using them, you'll use them everywhere. Some of you poor souls are unfortunate enough to be stuck on MySQL 5.7, either of your own ... Continue reading Emulating Window Functions in MySQL 5.7 ->

## Migrating Kafka topics without downtime

DevFeed: [Migrating Kafka topics without downtime](<https://devfeed.tech/articles/migrating-kafka-topics-without-downtime-39620.md>)

Original publisher: [Read original article](<https://www.gauravsarma.com/posts/2022-09-15_Migrating-Kafka-topics-without-downtime-f863819cfb3d>)

Published: 2022-09-15T00:00:00Z

Content type: tutorial

Language: en

Sources: [Gaurav Sarma's Blog](<https://devfeed.tech/sources/gaurav-sarma-s-blog.md>)

Topics: [Kafka](<https://devfeed.tech/topics/kafka.md>), [ordering](<https://devfeed.tech/topics/ordering.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [version](<https://devfeed.tech/topics/version.md>)

Tags: [downtime](<https://devfeed.tech/tags/downtime.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [partition](<https://devfeed.tech/tags/partition.md>), [versioning](<https://devfeed.tech/tags/versioning.md>)

### AI overview

A tutorial for migrating Kafka topics by creating versioned replacement topics, redirecting publishers and consumers, and draining the old topics. It explains how partition counts affect ordering, concurrency, scalability, and management overhead, and notes that the author did not find a direct tool for migration without downtime.

### Source excerpt

Each kafka topic defines the number of partitions and replication factors when it's created. However, once a topic is created, the partition count cannot be changed without affecting the ordering guarantees of the kafka partitions since kafka uses the following formula to calculate which partition a record should go to: partition\_id = partition\_key % number of partitions Kafka partitions are the gateway to concurrency and scalability...

## Rust atomics on x86: How and why

DevFeed: [Rust atomics on x86: How and why](<https://devfeed.tech/articles/rust-atomics-on-x86-how-and-why-35457.md>)

Original publisher: [Read original article](<https://darkcoding.net/software/rust-atomics-on-x86/>)

Author: Graham King

Published: 2022-01-30T23:18:06Z

Content type: article

Language: en

Sources: [Graham King](<https://devfeed.tech/sources/graham-king.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [x86](<https://devfeed.tech/topics/x86.md>), [ordering](<https://devfeed.tech/topics/ordering.md>)

Tags: [assembly](<https://devfeed.tech/tags/assembly.md>), [atomic](<https://devfeed.tech/tags/atomic.md>), [atomics](<https://devfeed.tech/tags/atomics.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [rust](<https://devfeed.tech/tags/rust.md>), [software](<https://devfeed.tech/tags/software.md>), [x86](<https://devfeed.tech/tags/x86.md>)

### AI overview

This article examines how Rust atomic memory orderings compile on x86. It finds that load and store operations generally produce the same instructions across orderings, while sequential consistency adds a full memory barrier. Read-modify-write operations also generally use the same instructions, though compiler reordering remains an important caveat.

### Source excerpt

On x86 it doesn't really matter what sync::atomic::Ordering you choose.

## I have joined Delivery Hero!

DevFeed: [I have joined Delivery Hero!](<https://devfeed.tech/articles/i-have-joined-delivery-hero-28382.md>)

Original publisher: [Read original article](<https://siddroid.com/post/post-i-have-joined-delivery-hero-in-berlin-germany/>)

Author: Siddhesh Patil

Published: 2021-11-11T12:21:39Z

Content type: opinion

Language: en

Sources: [Sid Patil - Android Engineer and Kotlin Advocate](<https://devfeed.tech/sources/sid-patil-android-engineer-and-kotlin-advocate.md>)

Topics: [ordering](<https://devfeed.tech/topics/ordering.md>), [Android](<https://devfeed.tech/topics/android.md>), [App](<https://devfeed.tech/topics/app.md>)

Tags: [android-engineer](<https://devfeed.tech/tags/android-engineer.md>), [berlin](<https://devfeed.tech/tags/berlin.md>), [career](<https://devfeed.tech/tags/career.md>), [career-update](<https://devfeed.tech/tags/career-update.md>), [delivery-hero](<https://devfeed.tech/tags/delivery-hero.md>), [deliveryhero](<https://devfeed.tech/tags/deliveryhero.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [food](<https://devfeed.tech/tags/food.md>), [food-delivery-apps-in-berlin](<https://devfeed.tech/tags/food-delivery-apps-in-berlin.md>), [foodora](<https://devfeed.tech/tags/foodora.md>), [foodpanda](<https://devfeed.tech/tags/foodpanda.md>), [germany](<https://devfeed.tech/tags/germany.md>), [new-job](<https://devfeed.tech/tags/new-job.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [orders](<https://devfeed.tech/tags/orders.md>), [pandora](<https://devfeed.tech/tags/pandora.md>), [patil](<https://devfeed.tech/tags/patil.md>), [paytm](<https://devfeed.tech/tags/paytm.md>), [paytm-insider](<https://devfeed.tech/tags/paytm-insider.md>), [q-commerce](<https://devfeed.tech/tags/q-commerce.md>), [sid-patil](<https://devfeed.tech/tags/sid-patil.md>), [siddhesh](<https://devfeed.tech/tags/siddhesh.md>)

### AI overview

The author announces joining Delivery Hero and relocating to Berlin, Germany. They describe their previous work on Paytm's chat-based payment experience and say they will build food ordering experiences as an Android engineer in Delivery Hero's tech division.

### Source excerpt

Super excited to share that I have joined Delivery Hero and relocated to Berlin, Germany. For the next chapter of my career, I will be helping shape ordering experiences of multiple food delivery and Q-commerce apps.

## CPU Out-of-Order Instruction Execution and Memory Ordering

DevFeed: [CPU Out-of-Order Instruction Execution and Memory Ordering](<https://devfeed.tech/articles/cpu-silently-disappointed-with-your-choice-of-instruction-ordering-35386.md>)

Original publisher: [Read original article](<https://darkcoding.net/software/cpu-silently-disappointed-with-your-choice-of-instruction-ordering/>)

Author: Graham King

Published: 2021-06-09T23:10:34Z

Content type: tutorial

Language: en

Sources: [Graham King](<https://devfeed.tech/sources/graham-king.md>)

Topics: [cpu](<https://devfeed.tech/topics/cpu.md>), [ordering](<https://devfeed.tech/topics/ordering.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Rust](<https://devfeed.tech/topics/rust.md>)

Tags: [cpu](<https://devfeed.tech/tags/cpu.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [rust](<https://devfeed.tech/tags/rust.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

A tutorial explores CPU out-of-order instruction execution through a two-thread example where both reads can observe zero. It discusses how the behavior is affected by cores, Rust memory ordering, and a Mutex.

### Source excerpt

An adventure in CPU out-of-order instruction execution.

## Guarantee Event Order with RxJS

DevFeed: [Guarantee Event Order with RxJS](<https://devfeed.tech/articles/guarantee-event-order-with-rxjs-21393.md>)

Original publisher: [Read original article](<https://juri.dev/blog/guarantee-event-order-with-rxjs/>)

Published: 2019-01-16T00:00:00Z

Content type: tutorial

Language: en

Sources: [Juri Strumpflohner](<https://devfeed.tech/sources/juri-strumpflohner.md>)

Topics: [ui](<https://devfeed.tech/topics/ui.md>), [web applications](<https://devfeed.tech/topics/web-applications.md>), [HTTP](<https://devfeed.tech/topics/http.md>)

Tags: [angular](<https://devfeed.tech/tags/angular.md>), [async](<https://devfeed.tech/tags/async.md>), [concatmap](<https://devfeed.tech/tags/concatmap.md>), [events](<https://devfeed.tech/tags/events.md>), [http](<https://devfeed.tech/tags/http.md>), [interface](<https://devfeed.tech/tags/interface.md>), [mergemap](<https://devfeed.tech/tags/mergemap.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [request](<https://devfeed.tech/tags/request.md>), [rxjs](<https://devfeed.tech/tags/rxjs.md>), [state](<https://devfeed.tech/tags/state.md>), [switchmap](<https://devfeed.tech/tags/switchmap.md>)

### AI overview

This tutorial explains how RxJS can preserve event ordering in dynamic user interfaces when asynchronous requests may complete out of order. It presents a checkbox example where rapid selection changes can produce an inconsistent list, then describes processing events sequentially with an RxJS subject and operator.

### Source excerpt

Lorem ipsum dolor sit amet

[Next page](<https://devfeed.tech/tags/ordering.md?cursor=WyIyMDE5LTAxLTE2VDAwOjAwOjAwKzAwOjAwIiwgIjE5OGI5NTZkLTkwMGYtNGJiNC05MzA0LWU5NzRhNzNmOTM0NyJd>)