# Sorting

Sorting is the computational process of arranging a collection of elements into a specified order according to a defined key.

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

## The General Stability of Ranking

DevFeed: [The General Stability of Ranking](<https://devfeed.tech/articles/the-general-stability-of-ranking-118107.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2607.01546>)

Author: Houming Chen, H. V. Jagadish

Published: 2026-11-05T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>)

Topics: [information retrieval](<https://devfeed.tech/topics/information-retrieval.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [convex](<https://devfeed.tech/tags/convex.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [database](<https://devfeed.tech/tags/database.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [error](<https://devfeed.tech/tags/error.md>), [faster](<https://devfeed.tech/tags/faster.md>), [gsc](<https://devfeed.tech/tags/gsc.md>), [guarantees](<https://devfeed.tech/tags/guarantees.md>), [independent](<https://devfeed.tech/tags/independent.md>), [influence](<https://devfeed.tech/tags/influence.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [properties](<https://devfeed.tech/tags/properties.md>), [query](<https://devfeed.tech/tags/query.md>), [ranking](<https://devfeed.tech/tags/ranking.md>), [rankings](<https://devfeed.tech/tags/rankings.md>), [robustness](<https://devfeed.tech/tags/robustness.md>), [sample](<https://devfeed.tech/tags/sample.md>), [sampling](<https://devfeed.tech/tags/sampling.md>), [save](<https://devfeed.tech/tags/save.md>), [setup](<https://devfeed.tech/tags/setup.md>)

### AI overview

General stability measures ranking robustness by distance from a target ranking, so users can assign different importance to changes such as replacing the top item versus swapping near-tied lower items; exact-match stability is a special case. The paper presents GSC_md sampling, whose worst-case runtime can be exponential, but uniform boundedness yields a sample budget independent of database size and dimension for fixed accuracy and confidence. Prefix-GSC reduces sorting when the distance has tail decay with bounded influence; Conv-SC approximates stability through convex volumes when the distance is quasiconvex. Experiments on seven real-data sources and generated inputs show that distance affects robustness conclusions. On three 500-item university datasets, Prefix-GSC had 1.22-1.98x median query speedups over GSC_md at 2% relative error and 95% confidence, including setup.

### Source excerpt

arXiv:2607.01546v2 Announce Type: replace Abstract: Rankings derived from weighted scoring functions are widely used in university rankings and employment candidate evaluations. Since ranking weights are often chosen by organizations or analysts, ranking stability asks whether a reported ranking persists under reasonable weight changes. Prior work defines volume-based stability as the fraction of the weight space that induces the target ranking exactly. This exact-match requirement can be too blunt: once a perturbed weight vector produces a different ranking, exact stability gives it no credit, whether the change replaces the top-ranked item or only swaps two nearly tied lower-ranked items. We propose general stability, a distance-based generalization that aggregates ranking regions according to a user-defined distance from the target ranking. This lets users specify which ranking changes matter in the application, while recovering exact stability as a special case. We extend existing methods and identify distance properties that permit faster general-stability computation with accuracy guarantees. Our sampling algorithm, $GSC_{md}$, can take exponential time in the worst case, but a property we call uniform boundedness gives a sample budget independent of database size and dimension at fixed accuracy and confidence. We develop Prefix-GSC, a sampling optimization that reduces sorting for distances satisfying a further property, tail decay with bounded influence. We also develop Conv-SC to approximate stability through convex volumes for distances satisfying a property we term quasiconvexity. Experiments on seven real-data sources and generated inputs show how distance affects robustness conclusions and when the algorithms save time. On three 500-item university datasets, Prefix-GSC achieves median query speedups of $1.22$--$1.98\times$ over $GSC_{md}$ at 2% relative error and 95% confidence, including method setup.

## Order-Dependent Complexity of Enumeration and Direct Access for Conjunctive Queries on Dynamic Data

DevFeed: [Order-Dependent Complexity of Enumeration and Direct Access for Conjunctive Queries on Dynamic Data](<https://devfeed.tech/articles/order-dependent-complexity-of-enumeration-and-direct-access-for-conjunctive-queries-on-dynamic-data-115961.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.04519>)

Author: Antoine Amarilli, Nofar Carmeli, Cl\\'emence Dumoulin

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>)

Topics: [computational complexity](<https://devfeed.tech/topics/computational-complexity.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [database](<https://devfeed.tech/tags/database.md>), [dynamic-data](<https://devfeed.tech/tags/dynamic-data.md>), [enumeration](<https://devfeed.tech/tags/enumeration.md>), [hierarchy](<https://devfeed.tech/tags/hierarchy.md>), [lower-bound](<https://devfeed.tech/tags/lower-bound.md>), [order](<https://devfeed.tech/tags/order.md>), [queries](<https://devfeed.tech/tags/queries.md>), [ranking](<https://devfeed.tech/tags/ranking.md>), [update](<https://devfeed.tech/tags/update.md>), [variables](<https://devfeed.tech/tags/variables.md>)

### AI overview

For dynamic conjunctive queries, ranked enumeration and direct access have efficient bounds when the requested lexicographic order is hierarchy-consistent. The proposed algorithms use linear preprocessing and logarithmic update time; enumeration provides constant delay, while retrieving the k-th tuple takes logarithmic access time. For non-hierarchy-consistent orders, the note establishes a lower bound for ranked direct access under updates. The abstract does not specify that lower bound's form.

### Source excerpt

arXiv:2611.04519v1 Announce Type: new Abstract: This note studies the fine-grained complexity of ranked enumeration and ranked direct access of conjunctive query answers over a dynamic database. We focus on lexicographically sorted answers, defined by an ordering on the query's free variables. From the literature, when no particular order is required, we know that when the query is self-join-free and q-hierarchical, we can build a data structure for enumeration (resp. direct access) with linear (resp. linearithmic) preprocessing and constant (resp. logarithmic) update time in the size of the database. For enumeration (resp. direct access), this data structure yields an algorithm that enumerates all query answers (resp. that returns the $k$-th query answer) with constant delay (resp. logarithmic access time). Our goal is to extend these results to ranked enumeration and ranked direct access, with the ranking function defined by a lexicographic order. We define a property on the order over the variables of $Q$, which we call being hierarchy-consistent. Given a user-specified query and hierarchy-consistent order, we first propose, for ranked enumeration under updates, an algorithm with linear preprocessing and logarithmic update time that enumerates all the query answers according to the user-specified order with constant delay. Moreover, for ranked direct access under updates, we propose an algorithm with linear preprocessing and logarithmic update time that returns the $k$-th tuple according to the user-specified order with logarithmic access time. In contrast, given a user-specified query and non-hierarchy-consistent order, we show a lower bound for ranked direct access under updates.

## Graphs Have Structure: Declarative Manifolds, 3D Z-Order Monoid Roll-ups, and Zero-Simulation Visual Analytics in a Graph DBMS

DevFeed: [Graphs Have Structure: Declarative Manifolds, 3D Z-Order Monoid Roll-ups, and Zero-Simulation Visual Analytics in a Graph DBMS](<https://devfeed.tech/articles/graphs-have-structure-declarative-manifolds-3d-z-order-monoid-roll-ups-and-zero-simulation-visual-analytics-in-a-graph-dbms-113648.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.01879>)

Author: Madhulatha Mandarapu, Sandeep Kunkunuru

Published: 2026-11-03T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>)

Topics: [Graphs](<https://devfeed.tech/topics/graphs.md>), [graph theory](<https://devfeed.tech/topics/graph-theory.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>), [Simulation](<https://devfeed.tech/topics/simulation.md>)

Tags: [2-5d](<https://devfeed.tech/tags/2-5d.md>), [3d](<https://devfeed.tech/tags/3d.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [aggregation](<https://devfeed.tech/tags/aggregation.md>), [ambient](<https://devfeed.tech/tags/ambient.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [builds](<https://devfeed.tech/tags/builds.md>), [class](<https://devfeed.tech/tags/class.md>), [client](<https://devfeed.tech/tags/client.md>), [continuous](<https://devfeed.tech/tags/continuous.md>), [cs-cg](<https://devfeed.tech/tags/cs-cg.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [cs-hc](<https://devfeed.tech/tags/cs-hc.md>), [databases](<https://devfeed.tech/tags/databases.md>), [declarative](<https://devfeed.tech/tags/declarative.md>), [dfs](<https://devfeed.tech/tags/dfs.md>), [graph](<https://devfeed.tech/tags/graph.md>), [graphs](<https://devfeed.tech/tags/graphs.md>), [order](<https://devfeed.tech/tags/order.md>), [simulation](<https://devfeed.tech/tags/simulation.md>), [structure](<https://devfeed.tech/tags/structure.md>), [zero](<https://devfeed.tech/tags/zero.md>)

### AI overview

Samyama Graph proposes making a graph's ambient structure explicit, with node labels mapped to Euclidean 3D, geo-spherical, causal-spacetime, or hierarchy manifolds. Its Structural-Geometric Index maps 3D locations to Morton-order intervals and supports regional SUM, COUNT, MIN, and MAX folds through index-resident trees; hierarchy roll-ups use DFS intervals. For 100,000 3D nodes, the abstract reports a 28.14 ms index build and SUM/MAX query times of 0.048/0.104 μs, respectively, versus property scans. Other described features include voxel-hashed virtual contacts weighted by graph-to-manifold distance, manifold-guided A* search (up to 3.80x fewer explored states than Dijkstra), and server-computed 3D layouts rendered through a non-WebGL isometric projection. These are claims reported in the supplied abstract excerpt.

### Source excerpt

arXiv:2611.01879v1 Announce Type: new Abstract: Every real-world graph is embedded in an ambient structural manifold: proteins fold in Euclidean space ($R^3$), telecom networks sit on a planetary surface ($S^2 \times R$), and ontologies and calendars form discrete subsumption posets ($(V, \sqsubseteq)$). Yet property graph databases treat node coordinates as opaque payload scalars, leave spatial proximity edges unindexed, and force visualizers into $O(V^2)$ client-side force-directed simulations that destroy true geometry and truncate hierarchy roll-ups. We elevate ambient manifold structure to a first-class primitive in Samyama Graph. First, we introduce a declarative and auto-detected structural convention contract (samyama.structure/1) persisted in .sgsnap headers that binds node labels to Euclidean 3D, Geo-Spherical, Causal Spacetime, or Poset Hierarchy manifolds. Second, we show that both discrete posets (via Order-Embedded Hierarchy $[tin, tout]$ DFS intervals) and continuous 3D manifolds (via a 63-bit 3D Morton Z-order Structural-Geometric Index, SGI) reduce regional aggregation to 1D rank-interval monoid folds answered directly from index-resident Fenwick trees (SUM, COUNT) and Segment Trees (MIN, MAX). At $100,000$ 3D nodes, SGI builds in $28.14$ ms and answers Morton-interval SUM and MAX roll-ups in $0.048\,\mu$s and $0.104\,\mu$s---$8,345.1\times$ and $3,824.4\times$ faster than property scans. Third, we introduce 3D voxel-hashed virtual contact edges weighted by Topological--Geometric Stress $\sigma(u,v) = d_{graph}(u,v) / d_{manifold}(u,v)$ to isolate long-range tertiary folds, plus manifold-guided $A^*$ shortest-path search that cuts explored states by up to $3.80\times$ over Dijkstra. Fourth, we replace client layout simulation with server-computed 3D Cone-Tree/Ribbon coordinates and a non-WebGL 2.5D Isometric projection with painter's-order depth sorting and sub-millisecond Level-of-Detail (LoD) macro-cuts.

## Apache Iceberg Clustering and Sort Order Evolution: When to Rewrite Data

DevFeed: [Apache Iceberg Clustering and Sort Order Evolution: When to Rewrite Data](<https://devfeed.tech/articles/apache-iceberg-clustering-and-sort-order-evolution-when-to-rewrite-data-102840.md>)

Original publisher: [Read original article](<https://www.dremio.com/blog/apache-iceberg-clustering-and-sort-order-evolution-when-to-rewrite-data/>)

Author: Alex Merced

Published: 2026-10-27T18:56:57Z

Content type: article

Language: en

Sources: [Dremio](<https://devfeed.tech/sources/dremio.md>)

Topics: [Apache Iceberg](<https://devfeed.tech/topics/apache-iceberg.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>), [Apache Spark](<https://devfeed.tech/topics/spark.md>), [parquet](<https://devfeed.tech/topics/parquet.md>), [Grafana](<https://devfeed.tech/topics/grafana.md>), [Amazon S3 Tables](<https://devfeed.tech/topics/amazon-s3-tables.md>)

Tags: [apache-iceberg](<https://devfeed.tech/tags/apache-iceberg.md>), [data-lakehouse](<https://devfeed.tech/tags/data-lakehouse.md>), [dremio-blog-open-data-insights](<https://devfeed.tech/tags/dremio-blog-open-data-insights.md>), [evolution](<https://devfeed.tech/tags/evolution.md>), [rewrite](<https://devfeed.tech/tags/rewrite.md>), [sort](<https://devfeed.tech/tags/sort.md>)

### AI overview

Changing an Apache Iceberg sort order updates table metadata for future writes; it does not reorder existing files or refresh their file statistics. Rewriting old files is worthwhile only when measured pruning and query savings justify the I/O, commit load, and operational risk. The text recommends identifying frequent, high-value predicates, recording baseline files read, bytes scanned, and query latency, then testing the new sort order and a bounded rewrite on representative files. Compare pruning and end-to-end performance after each batch, while monitoring commit latency, retries, storage activity, and coordinator load. If gains persist, expand in controlled waves; stop if payback is weak or operational costs exceed the measured benefit. Exact DDL and rewrite procedures depend on the Iceberg, engine, and catalog versions, so verify supported syntax and APIs in the deployed environment. The suggested batch sizes and cluster observations are examples, not universal guarantees.

### Source excerpt

Evolve Iceberg sort orders safely, measure pruning quality, choose sort or Z-order rewrites, and decide when existing data justifies a controlled rewrite. The post Apache Iceberg Clustering and Sort Order Evolution: When to Rewrite Data appeared first on Dremio.

## Sorting a Python Dictionary: Values, Keys, and More

DevFeed: [Sorting a Python Dictionary: Values, Keys, and More](<https://devfeed.tech/articles/sorting-a-python-dictionary-values-keys-and-more-100403.md>)

Original publisher: [Read original article](<https://realpython.com/sort-python-dictionary/>)

Author: Ian Currie

Published: 2026-10-25T14:00:00Z

Content type: tutorial

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>), [ordering](<https://devfeed.tech/topics/ordering.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [22](<https://devfeed.tech/tags/22.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [absolute](<https://devfeed.tech/tags/absolute.md>), [code](<https://devfeed.tech/tags/code.md>), [compare](<https://devfeed.tech/tags/compare.md>), [fast](<https://devfeed.tech/tags/fast.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [keep](<https://devfeed.tech/tags/keep.md>), [key](<https://devfeed.tech/tags/key.md>), [keys](<https://devfeed.tech/tags/keys.md>), [learn](<https://devfeed.tech/tags/learn.md>), [nested](<https://devfeed.tech/tags/nested.md>), [python](<https://devfeed.tech/tags/python.md>), [sort](<https://devfeed.tech/tags/sort.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [techniques](<https://devfeed.tech/tags/techniques.md>), [value](<https://devfeed.tech/tags/value.md>), [values](<https://devfeed.tech/tags/values.md>)

### AI overview

Python's `sorted()` returns a new list, so sorting dictionary entries typically means sorting `dict.items()` and optionally rebuilding a dictionary with `dict()`. Default tuple ordering sorts by key; pass a `key` callback such as `lambda item: item[1]` or `operator.itemgetter(1)` to sort by value, and use `reverse=True` for descending order. For nested fields, a named function can apply defaults with `.get()` when values may be missing. Dictionaries cannot be sorted in place. The text reports `itemgetter()` outperforming a lambda in one benchmark, and a list sorting faster than sorting and rebuilding a dictionary in another; dictionary lookups were much faster than linear list searches in its sample. It cautions that timings vary by data and system. For repeated sorting, a list may fit better; for frequent lookups, a dictionary is faster. Ordered dictionary iteration also does not ensure custom key order will survive JSON or cross-language use.

### Source excerpt

Learn how to sort a Python dictionary by value or key, handle nested attributes, and compare techniques to keep your code fast and readable.

## Transformers Learn Two Competing Sorting Algorithms, and Only One Length-Generalizes

DevFeed: [Transformers Learn Two Competing Sorting Algorithms, and Only One Length-Generalizes](<https://devfeed.tech/articles/transformers-learn-two-competing-sorting-algorithms-and-only-one-length-generalizes-94219.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.26974>)

Author: Khashayar Gatmiry, Nathan W. Henry, Chloe H. Su, Emmanuel Abbe, Samy Bengio, Melanie Weber, Jonathan A. Kelner, Peter L. Bartlett

Published: 2026-10-21T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>), [ordering](<https://devfeed.tech/topics/ordering.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [attention](<https://devfeed.tech/tags/attention.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [learning](<https://devfeed.tech/tags/learning.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [sorting-algorithms](<https://devfeed.tech/tags/sorting-algorithms.md>), [specialization](<https://devfeed.tech/tags/specialization.md>), [training](<https://devfeed.tech/tags/training.md>), [transformers](<https://devfeed.tech/tags/transformers.md>), [two-layer](<https://devfeed.tech/tags/two-layer.md>), [weight](<https://devfeed.tech/tags/weight.md>)

### AI overview

Two-layer transformers trained to sort fixed-length sequences can learn either of two solution types depending on initialization. One does not use the second attention layer to sort and fails to generalize to longer sequences; the other uses both layers and generalizes perfectly. The authors report that initialization can steer which solution emerges. In the generalizing solution, layer-wise specialization helps handle inputs that are rare at training length but more common at longer lengths, while the second layer uses context from the first to narrow its search. On the related minimum-finding task, the two solution types show the opposite generalization pattern: the two-layer solution generalizes worse than the single-attention solution.

### Source excerpt

arXiv:2610.26974v1 Announce Type: new Abstract: We show that two-layer transformers trained to near-zero loss on a sorting task converge to one of two mechanistically distinct solution classes depending on their initialization. One solution class consists of solutions that do not use the second attention layer to sort, but also fail to length-generalize. The other, which uses both attention layers, length-generalizes perfectly, despite only being trained to sort sequences of a fixed length. By carefully choosing the weight initialization, we demonstrate that we can steer the model toward learning one solution or the other. We identify input types that are rare at the training length but increasingly common at longer sequence lengths as a source of this disparity in length-generalization, and find that layer-wise specialization of the second class of solutions allows them to handle these rare sequences more accurately. In the second class, we discover a mechanism by which the second layer attention can use the contextual information gathered by the first layer attention to reduce its search space. On the related task of finding the minimum of a sequence, we find a similar two solution-type phenomenon, but with the opposite generalization pattern, where a different form of layer-wise specialization causes the two-layer solution to length-generalize worse than the single-attention solution.

## Guided Merge Sort : An Optimized Sorting that Picks the Best from Ordinary and Multi-Way Merge Sort Algorithms

DevFeed: [Guided Merge Sort : An Optimized Sorting that Picks the Best from Ordinary and Multi-Way Merge Sort Algorithms](<https://devfeed.tech/articles/guided-merge-sort-an-optimized-sorting-that-picks-the-best-from-ordinary-and-multi-way-merge-sort-algorithms-61152.md>)

Original publisher: [Read original article](<https://towardsdatascience.com/guided-merge-sort-an-optimized-sorting-that-picks-the-best-from-ordinary-and-multi-way-merge-sort-algorithms/>)

Author: Tigran Hayrapetyan

Published: 2026-09-28T15:30:01Z

Content type: article

Language: en

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

Topics: [Sorting](<https://devfeed.tech/topics/sorting.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [computational complexity](<https://devfeed.tech/topics/computational-complexity.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [computer-science](<https://devfeed.tech/tags/computer-science.md>), [editor-s-picks](<https://devfeed.tech/tags/editor-s-picks.md>), [merge-sort](<https://devfeed.tech/tags/merge-sort.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [sorting-algorithms](<https://devfeed.tech/tags/sorting-algorithms.md>)

### AI overview

The article introduces guided K-merge, which merges multiple sorted sequences using isomorphic code fragments and goto, and guided K-merge sort. It reports theoretical time reductions over sorted-array merging without priority-queue overhead, and practical speedups of up to 15% over merge sort depending on the data being sorted.

### Source excerpt

A solution where the "goto" operator becomes irreplaceable. The post Guided Merge Sort : An Optimized Sorting that Picks the Best from Ordinary and Multi-Way Merge Sort Algorithms appeared first on Towards Data Science.

## Deel's Jev numbers, posted by TypeSafe

DevFeed: [Deel's Jev numbers, posted by TypeSafe](<https://devfeed.tech/articles/deel-s-jev-numbers-posted-by-typesafe-59951.md>)

Original publisher: [Read original article](<https://jevdaily.com/issues/2026-09-25>)

Author: Jev Daily

Published: 2026-09-25T17:00:00Z

Content type: article

Language: en

Sources: [Jev Daily](<https://devfeed.tech/sources/jev-daily.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>), [pii](<https://devfeed.tech/topics/pii.md>), [Ollama](<https://devfeed.tech/topics/ollama.md>), [email](<https://devfeed.tech/topics/email.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [built-with-it](<https://devfeed.tech/tags/built-with-it.md>), [ollama](<https://devfeed.tech/tags/ollama.md>), [pii](<https://devfeed.tech/tags/pii.md>), [someone-measured-it](<https://devfeed.tech/tags/someone-measured-it.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [writing-criteria](<https://devfeed.tech/tags/writing-criteria.md>)

### AI overview

The document reports TypeSafe AI's publication of Deel's measurements across six classification tasks, including improvements in repeat-question matching and expense categorization. It also describes a small Tev1 model running locally through Ollama and an experimental two-stage email classification workflow.

### Source excerpt

TypeSafe AI published Deel's measurements on six classification tasks, including repeat-question matching going from 70% to 97% and expense categorization...

## Quiz: Sorting Algorithms in Python

DevFeed: [Quiz: Sorting Algorithms in Python](<https://devfeed.tech/articles/quiz-sorting-algorithms-in-python-58465.md>)

Original publisher: [Read original article](<https://realpython.com/quizzes/sorting-algorithms-python/>)

Author: Real Python

Published: 2026-09-23T12:00:00Z

Content type: tutorial

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>), [Python](<https://devfeed.tech/topics/python.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [big-o-notation](<https://devfeed.tech/tags/big-o-notation.md>), [bubble](<https://devfeed.tech/tags/bubble.md>), [divide-and-conquer](<https://devfeed.tech/tags/divide-and-conquer.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [merge](<https://devfeed.tech/tags/merge.md>), [python](<https://devfeed.tech/tags/python.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [sort](<https://devfeed.tech/tags/sort.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [theoretical](<https://devfeed.tech/tags/theoretical.md>), [time](<https://devfeed.tech/tags/time.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

An interactive 12-question quiz tests understanding of bubble sort, insertion sort, merge sort, Quicksort, and Timsort, along with Big O efficiency, recursion, and divide-and-conquer techniques in Python.

### Source excerpt

Check your understanding of bubble sort, insertion sort, merge sort, Quicksort, and Timsort, and how Big O notation compares their efficiency.

## Deadlocks are a lock ordering bug, and lock ordering is a design decision

DevFeed: [Deadlocks are a lock ordering bug, and lock ordering is a design decision](<https://devfeed.tech/articles/deadlocks-are-a-lock-ordering-bug-and-lock-ordering-is-a-design-decision-55691.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/56-deadlocks-are-a-lock-ordering-bug/>)

Author: hello@ankit-rana.com

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

Content type: article

Language: en

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

Topics: [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [ordering](<https://devfeed.tech/topics/ordering.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Database](<https://devfeed.tech/topics/database.md>), [locking](<https://devfeed.tech/topics/locking.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>)

Tags: [concurrency](<https://devfeed.tech/tags/concurrency.md>), [database](<https://devfeed.tech/tags/database.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [deadlocks](<https://devfeed.tech/tags/deadlocks.md>), [java](<https://devfeed.tech/tags/java.md>), [locking](<https://devfeed.tech/tags/locking.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

The article explains how database deadlocks arise when concurrent transactions acquire the same locks in opposite orders. It recommends imposing a consistent global lock order, typically by sorting identifiers, to prevent circular wait in transfers and batch operations.

### Source excerpt

A deadlock needs four conditions and the only one you control is circular wait, which is why every deadlock reduces to two transactions acquiring the same locks in opposite orders. Imposing a global order on lock acquisition, usually by sorting the identifiers before touching any row, makes the cycle impossible to form. A database deadlock is the survivable version because the engine detects it and kills a victim, and an application level deadlock across two mutexes has no detector and simply hangs.

## CodeSOD: An Odd Sort

DevFeed: [CodeSOD: An Odd Sort](<https://devfeed.tech/articles/codesod-an-odd-sort-28504.md>)

Original publisher: [Read original article](<https://thedailywtf.com/articles/an-odd-sort>)

Author: Remy Porter

Published: 2026-09-15T06:30:00Z

Content type: opinion

Language: en

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

Topics: [Code](<https://devfeed.tech/topics/code.md>), [PowerShell](<https://devfeed.tech/topics/powershell.md>), [Script](<https://devfeed.tech/topics/script.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [codesod](<https://devfeed.tech/tags/codesod.md>), [csv](<https://devfeed.tech/tags/csv.md>), [excel](<https://devfeed.tech/tags/excel.md>), [powershell](<https://devfeed.tech/tags/powershell.md>), [report](<https://devfeed.tech/tags/report.md>), [script](<https://devfeed.tech/tags/script.md>), [sorting](<https://devfeed.tech/tags/sorting.md>)

### AI overview

The article critiques a PowerShell script that queries Active Directory for users and their last logon times. It explains that the script's alphabet-based approach does not correctly sort names, performs unnecessary searches and property loading, and generates a CSV report for Excel despite these inefficiencies.

### Source excerpt

Let's say we wanted to query Active Directory and print out a report of all of our users, and their last logon time. That seems like a pretty normal task for a Powershell script. It'd probably be short and easy to read, at least if it were written by a normal person. Alice sends us one that wasn't. She's already done us a favor, as she writes: "Code cleaned up and indented for the whitespace-missing-impaired." ##################################### # lists accounts and selected attributes alphabetically ##################################### foreach( $letter in "a", "b", "c"......"z") { $strfilter = $letter + "*" $objdomain = New-object System.DirectoryServices.DirectoryEntry $objSearcher = New-object System.DirectoryServices.DirectorySearcher $objSearcher.SearchRoot = $objdomain $objSearcher.Filter = $strFilter $objSearcher.PropertiesToLoad.Add("name"); $colResults = $objSearcher.FindAll() foreach($result in $colResults) { $name = $result.Properties.Name $searcher = New-Object DirectoryServices.DirectorySearcher([adsi]"") $searcher.filter "(&(objectCategory=User)(sAMAccountName=$name))" $users = searcher.FindAll() foreach($user in $users) { Write-Output $user.properties.item("name") + "," + $user.properties.item("lastLogon") } } } This accomplishes sorting alphabetically by iterating across the alphabet. Which, I suspect, isn't going to actually get them in alphabetical order; it makes sure that albert and alice appear before bob, but doesn't enforce that albert must come before alice. In any case, we iterate across the alphabet, and then create a searcher that finds a*, then b*, etc. We explicitly tell the searcher that the only property we care about is the name field, so that we don't load unnecessary fields, like the ones we want to report on. We then iterate across the list of names, construct a new searcher, and search for the account with the username we fetched. That lets us get all of the fields we need, including the ones we aren't going to use. Now, we sea

## Desktop Settings: Removing technical jargon

DevFeed: [Desktop Settings: Removing technical jargon](<https://devfeed.tech/articles/desktop-settings-removing-technical-jargon-50478.md>)

Original publisher: [Read original article](<https://blog.thunderbird.net/2026/09/desktop-settings-removing-technical-jargon/>)

Author: Aly Blenkin

Published: 2026-09-09T15:25:40Z

Content type: article

Language: en

Sources: [The Thunderbird Blog](<https://devfeed.tech/sources/the-thunderbird-blog.md>)

Topics: [App](<https://devfeed.tech/topics/app.md>), [interface](<https://devfeed.tech/topics/interface.md>), [copy](<https://devfeed.tech/topics/copy.md>), [User Interfaces](<https://devfeed.tech/topics/user-interfaces.md>), [test](<https://devfeed.tech/topics/test.md>), [Users](<https://devfeed.tech/topics/users.md>), [audit](<https://devfeed.tech/topics/audit.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>)

Tags: [audit](<https://devfeed.tech/tags/audit.md>), [content](<https://devfeed.tech/tags/content.md>), [copy](<https://devfeed.tech/tags/copy.md>), [design](<https://devfeed.tech/tags/design.md>), [desktop](<https://devfeed.tech/tags/desktop.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [incremental](<https://devfeed.tech/tags/incremental.md>), [notifications](<https://devfeed.tech/tags/notifications.md>), [research](<https://devfeed.tech/tags/research.md>), [settings](<https://devfeed.tech/tags/settings.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [technical](<https://devfeed.tech/tags/technical.md>), [test](<https://devfeed.tech/tags/test.md>), [thunderbird](<https://devfeed.tech/tags/thunderbird.md>)

### AI overview

The Thunderbird team describes research and incremental redesign work to make desktop settings easier to understand. It audited more than 250 content blocks, tested clearer copy with new users, and identified interface interactions that still need refinement.

### Source excerpt

Our goal for this phase of work is to remove the technical jargon, use plain language, and make it effortless for everyone to make informed decisions about their settings. With over 250 blocks of settings content to untangle, we aimed for incremental improvements rather than striving for perfection. While our previous research leaned heavily on [...] The post Desktop Settings: Removing technical jargon appeared first on The Thunderbird Blog.

## Benchmarking vector indexes

DevFeed: [Benchmarking vector indexes](<https://devfeed.tech/articles/benchmarking-vector-indexes-14092.md>)

Original publisher: [Read original article](<https://www.percona.com/blog/benchmarking-vector-indexes/>)

Author: Evgeniy Patlan

Published: 2026-08-27T13:35:32Z

Content type: article

Language: en

Sources: [Percona](<https://devfeed.tech/sources/blog-percona.md>)

Topics: [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [Ground truth / benchmark quality](<https://devfeed.tech/topics/ground-truth-benchmark-quality.md>), [Database](<https://devfeed.tech/topics/database.md>), [ann](<https://devfeed.tech/topics/ann.md>), [dataset](<https://devfeed.tech/topics/dataset.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>)

Tags: [ai-vector](<https://devfeed.tech/tags/ai-vector.md>), [ann](<https://devfeed.tech/tags/ann.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [blog](<https://devfeed.tech/tags/blog.md>), [blog-post](<https://devfeed.tech/tags/blog-post.md>), [data](<https://devfeed.tech/tags/data.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [database-trends](<https://devfeed.tech/tags/database-trends.md>), [databases](<https://devfeed.tech/tags/databases.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [embeddings](<https://devfeed.tech/tags/embeddings.md>), [index](<https://devfeed.tech/tags/index.md>), [measurements](<https://devfeed.tech/tags/measurements.md>), [model](<https://devfeed.tech/tags/model.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [percona](<https://devfeed.tech/tags/percona.md>), [points](<https://devfeed.tech/tags/points.md>), [report](<https://devfeed.tech/tags/report.md>), [run](<https://devfeed.tech/tags/run.md>), [search](<https://devfeed.tech/tags/search.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [vector-search](<https://devfeed.tech/tags/vector-search.md>), [vectorsearch](<https://devfeed.tech/tags/vectorsearch.md>)

### AI overview

This article explains how Percona's vector-bench measures vector indexes by building database engines from pinned versions, running them in identical containers with the same data and hardware, and comparing consistent measurements. It describes embeddings, exact search, approximate nearest neighbour search, and ground truth as the brute-force reference needed to evaluate index accuracy.

### Source excerpt

Nearly every database has vector search now, and every one of them has a blog post with a big number in it. Almost none of those numbers can be checked, because the thing that makes them meaningful is usually missing. We built a vector-bench to stop guessing. You name the engines you want, build them ... Continued The post Benchmarking vector indexes appeared first on Percona.

## Coding Challenge #130 - Sort Visualiser

DevFeed: [Coding Challenge #130 - Sort Visualiser](<https://devfeed.tech/articles/coding-challenge-130-sort-visualiser-29206.md>)

Original publisher: [Read original article](<https://codingchallenges.substack.com/p/coding-challenge-130-sort-visualiser>)

Author: John Crickett

Published: 2026-08-08T08:01:19Z

Content type: tutorial

Language: en

Sources: [Coding Challenges](<https://devfeed.tech/sources/coding-challenges.md>)

Topics: [Sorting](<https://devfeed.tech/topics/sorting.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [User Interfaces](<https://devfeed.tech/topics/user-interfaces.md>), [implementation](<https://devfeed.tech/topics/implementation.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [animation](<https://devfeed.tech/tags/animation.md>), [coding](<https://devfeed.tech/tags/coding.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [tool](<https://devfeed.tech/tags/tool.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

Coding Challenge #130 asks readers to build a sorting algorithm visualiser that animates how eight classic algorithms operate on arrays. The project also provides practice with UI rendering, animation timing, and clean abstractions, while allowing choices such as algorithm, sample size, data order, display mode, and animation speed.

### Source excerpt

This challenge is to build your own tool to visualise how sorting algorithms work.

## Turn any table sortable in 20 lines

DevFeed: [Turn any table sortable in 20 lines](<https://devfeed.tech/articles/turn-any-table-sortable-in-20-lines-9027.md>)

Original publisher: [Read original article](<https://markodenic.tech/turn-any-table-sortable-in-20-lines/>)

Author: Marko

Published: 2026-07-17T12:26:58Z

Content type: tutorial

Language: en

Sources: [Marko Denic Tech](<https://devfeed.tech/sources/marko-denic-tech.md>)

Topics: [JavaScript](<https://devfeed.tech/topics/javascript.md>), [HTML](<https://devfeed.tech/topics/html.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>), [Web Development](<https://devfeed.tech/topics/web-development.md>)

Tags: [blog-for-developers](<https://devfeed.tech/tags/blog-for-developers.md>), [build-faster](<https://devfeed.tech/tags/build-faster.md>), [code](<https://devfeed.tech/tags/code.md>), [code-productivity](<https://devfeed.tech/tags/code-productivity.md>), [code-smarter](<https://devfeed.tech/tags/code-smarter.md>), [content-monetization](<https://devfeed.tech/tags/content-monetization.md>), [css](<https://devfeed.tech/tags/css.md>), [css-animation](<https://devfeed.tech/tags/css-animation.md>), [css-performance](<https://devfeed.tech/tags/css-performance.md>), [developer-growth](<https://devfeed.tech/tags/developer-growth.md>), [developer-resources](<https://devfeed.tech/tags/developer-resources.md>), [email-newsletter-for-coders](<https://devfeed.tech/tags/email-newsletter-for-coders.md>), [front-end-development](<https://devfeed.tech/tags/front-end-development.md>), [github-profile-automation](<https://devfeed.tech/tags/github-profile-automation.md>), [html](<https://devfeed.tech/tags/html.md>), [html-tips](<https://devfeed.tech/tags/html-tips.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [javascript-tricks](<https://devfeed.tech/tags/javascript-tricks.md>), [learn-to-code](<https://devfeed.tech/tags/learn-to-code.md>), [markdown](<https://devfeed.tech/tags/markdown.md>), [responsive-design-tips](<https://devfeed.tech/tags/responsive-design-tips.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [ui](<https://devfeed.tech/tags/ui.md>), [web-dev-newsletter](<https://devfeed.tech/tags/web-dev-newsletter.md>), [web-development](<https://devfeed.tech/tags/web-development.md>), [web-development-tips](<https://devfeed.tech/tags/web-development-tips.md>), [weekly-dev-tips](<https://devfeed.tech/tags/weekly-dev-tips.md>), [workflow-optimization](<https://devfeed.tech/tags/workflow-optimization.md>)

### AI overview

A concise tutorial showing how to make a plain HTML table sortable with about 20 lines of vanilla JavaScript. It explains moving existing DOM rows, reversing sort direction, parsing numeric values correctly, and falling back to text sorting.

### Source excerpt

Make any HTML table sortable in 20 lines of vanilla JS.

## GitHub Mobile: Improved filters and sorting for Copilot sessions

DevFeed: [GitHub Mobile: Improved filters and sorting for Copilot sessions](<https://devfeed.tech/articles/github-mobile-improved-filters-and-sorting-for-copilot-sessions-71608.md>)

Original publisher: [Read original article](<https://github.blog/changelog/2026-07-10-github-mobile-improved-filters-and-sorting-for-copilot-sessions>)

Author: Allison

Published: 2026-07-10T09:45:30Z

Content type: release

Language: en

Sources: [GitHub Changelog](<https://devfeed.tech/sources/github-changelog.md>)

Topics: [Sorting](<https://devfeed.tech/topics/sorting.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [GitHub Copilot](<https://devfeed.tech/topics/github-copilot.md>), [iOS](<https://devfeed.tech/topics/ios.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [copilot](<https://devfeed.tech/tags/copilot.md>), [filter](<https://devfeed.tech/tags/filter.md>), [github](<https://devfeed.tech/tags/github.md>), [github-mobile](<https://devfeed.tech/tags/github-mobile.md>), [ios](<https://devfeed.tech/tags/ios.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [repository](<https://devfeed.tech/tags/repository.md>), [sessions](<https://devfeed.tech/tags/sessions.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [status](<https://devfeed.tech/tags/status.md>), [type](<https://devfeed.tech/tags/type.md>)

### AI overview

GitHub Mobile adds filters and sorting to help users find Copilot sessions as their lists grow. Filters cover active (non-archived) sessions, status, repository, type, and agent. Sorting includes most recent, oldest, active first, and needs-attention first; changing sort order preserves the current filters. The feature is available in the latest production build on iOS and Android.

### Source excerpt

GitHub Mobile now includes improved filters and sorting for Copilot sessions, making it easier to find the right session as your session list grows. You can now narrow your session...

## Zaks's suffix-reversal algorithm for generating permutations

DevFeed: [Zaks's suffix-reversal algorithm for generating permutations](<https://devfeed.tech/articles/an-elegant-formulation-inspired-by-the-one-and-only-paper-bill-gates-ever-wrote-37563.md>)

Original publisher: [Read original article](<https://blog.klipse.tech/aboulafia/2026/07/06/an-elegant-formulation-inspired-by-bill-gates.html>)

Author: Yehonathan Sharvit

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

Content type: article

Language: en

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

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>), [ordering](<https://devfeed.tech/topics/ordering.md>)

Tags: [aboulafia](<https://devfeed.tech/tags/aboulafia.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [math](<https://devfeed.tech/tags/math.md>), [permutations](<https://devfeed.tech/tags/permutations.md>), [reversing](<https://devfeed.tech/tags/reversing.md>), [sequence](<https://devfeed.tech/tags/sequence.md>), [sorting](<https://devfeed.tech/tags/sorting.md>)

### AI overview

This second article in a series connects Aboulafia's recursive Tserouf permutation algorithm with Shimon Zaks's 1984 algorithm. It explains how Zaks generates permutations by repeatedly reversing suffixes and describes the recursive sequence of suffix lengths behind the ordering.

### Source excerpt

Aboulafia's Tserouf - Part 2 of 4 <- Previous: An algorithm ignored for 700 years - Next: Too big to draw, but yet drawable ->

## Domain Search is now available through the Vercel CLI

DevFeed: [Domain Search is now available through the Vercel CLI](<https://devfeed.tech/articles/domain-search-is-now-available-through-the-vercel-cli-903.md>)

Original publisher: [Read original article](<https://vercel.com/changelog/domain-search-is-now-available-through-the-vercel-cli>)

Author: Elliot Dauber

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

Content type: release

Language: en

Sources: [Vercel News](<https://devfeed.tech/sources/vercel-news.md>)

Topics: [Command-line interface](<https://devfeed.tech/topics/cli.md>), [Vercel](<https://devfeed.tech/topics/vercel.md>), [Availability](<https://devfeed.tech/topics/availability.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>)

Tags: [availability](<https://devfeed.tech/tags/availability.md>), [cli](<https://devfeed.tech/tags/cli.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [upgrade](<https://devfeed.tech/tags/upgrade.md>), [vercel](<https://devfeed.tech/tags/vercel.md>)

### AI overview

Vercel CLI now supports domain searches across supported top-level domains, returning availability and pricing results. Users can filter by TLD, exclude unavailable domains, sort results, and must upgrade to version 54.10.1 to use the feature.

### Source excerpt

You can now use the Vercel CLI to search domains. Using the vercel domains search command, you can supply a domain name and retrieve availability and price results for all TLDs that Vercel supports. You can also filter by TLD, apply sorting, and filter out unavailable domains. Upgrade your Vercel CLI to version 54.10.1 to get started. Read more

## Quarkus Hibernate with Panache Next renamed to Quarkus Data Hibernate

DevFeed: [Quarkus Hibernate with Panache Next renamed to Quarkus Data Hibernate](<https://devfeed.tech/articles/quarkus-hibernate-with-panache-next-renamed-to-quarkus-data-hibernate-43648.md>)

Original publisher: [Read original article](<https://quarkus.io/blog/panache-next-renamed-to-quarkus-data/>)

Author: Stéphane Épardaud (https://twitter.com/UnFroMage)

Published: 2026-05-28T00:00:00Z

Content type: release

Language: en

Sources: [Quarkus - Supersonic Subatomic Java](<https://devfeed.tech/sources/quarkus-supersonic-subatomic-java.md>)

Topics: [Quarkus](<https://devfeed.tech/topics/quarkus.md>), [Hibernate](<https://devfeed.tech/topics/hibernate.md>), [reactive](<https://devfeed.tech/topics/reactive.md>), [annotation-processor](<https://devfeed.tech/topics/annotation-processor.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [builds](<https://devfeed.tech/topics/builds.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [make](<https://devfeed.tech/topics/make.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [Repository](<https://devfeed.tech/topics/repository.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>), [deprecated](<https://devfeed.tech/topics/deprecated.md>)

Tags: [annotation-processor](<https://devfeed.tech/tags/annotation-processor.md>), [bug-fixes](<https://devfeed.tech/tags/bug-fixes.md>), [builds](<https://devfeed.tech/tags/builds.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [deprecated](<https://devfeed.tech/tags/deprecated.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [hibernate](<https://devfeed.tech/tags/hibernate.md>), [make](<https://devfeed.tech/tags/make.md>), [maven](<https://devfeed.tech/tags/maven.md>), [quarkus](<https://devfeed.tech/tags/quarkus.md>), [re](<https://devfeed.tech/tags/re.md>), [reactive](<https://devfeed.tech/tags/reactive.md>), [reactive-transactions](<https://devfeed.tech/tags/reactive-transactions.md>), [security](<https://devfeed.tech/tags/security.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

Quarkus renamed Hibernate with Panache Next to Quarkus Data Hibernate and moved the experimental extension closer to the Jakarta Data standard. The release changes APIs and naming, adds support for reactive transactions, non-blocking startup methods, repositories, upsert operations, security annotations, and other fixes, while requesting community feedback on paging, naming, and build configuration.

### Source excerpt

Goodbye Hibernate with Panache Next... welcome Quarkus Data Hibernate 🥳 It's already been a while since we introduced Quarkus Hibernate with Panache Next, and since then, we've decided to move closer to the Jakarta Data standard, as well as rename the module to Quarkus Data Hibernate. I'll repeat the original disclaimer: this is a new extension, which is experimental, which means everything about it can (and probably will) change: the extension name, the package names, the class names and even the API. We are releasing it because we feel it's in a good shape to be tested and discussed by the community, and we hope to get better feedback before we commit to anything like names or API. Please report feedback either on Zulip or via GitHub issues. What changed since last time? Pivoted from the Panache 1 Sort type to the Jakarta Data Order type for sorting: https://github.com/quarkusio/quarkus/issues/53429 Supported @Transactional for Hibernate Reactive transactions: https://github.com/quarkusio/quarkus/issues/47698 Support non-blocking @Startup methods: https://github.com/quarkusio/quarkus/issues/50175 The @Repository annotation is now optional on nested repositories: https://github.com/quarkusio/quarkus/issues/50178 Added a codestart: https://github.com/quarkusio/quarkus/issues/51565 Make sure the Hibernate Reactive dependency is optional: https://github.com/quarkusio/quarkus/pull/52265 Deprecated the Parameters class in favour of Map.of: https://github.com/quarkusio/quarkus/pull/52583 Added upsert operation: https://github.com/quarkusio/quarkus/pull/52574 Make StatelessSession injectable for Hibernate Reactive https://github.com/quarkusio/quarkus/issues/47462 Support security annotations on repositories: https://github.com/quarkusio/quarkus/issues/53623 Support @InjectMock on repositories: https://github.com/quarkusio/quarkus/issues/53873 And many other bug fixes. Need feedback We're currently working on various issues, but we could especially use feedback on the follow

## Vercel Domains now supports price sorting and availability filtering

DevFeed: [Vercel Domains now supports price sorting and availability filtering](<https://devfeed.tech/articles/vercel-domains-now-supports-price-sorting-and-availability-filtering-1144.md>)

Original publisher: [Read original article](<https://vercel.com/changelog/vercel-domains-now-supports-price-sorting-and-availability-filtering>)

Author: Elliot Dauber

Published: 2026-05-26T00:00:00Z

Content type: release

Language: en

Sources: [Vercel News](<https://devfeed.tech/sources/vercel-news.md>)

Topics: [Vercel](<https://devfeed.tech/topics/vercel.md>), [Availability](<https://devfeed.tech/topics/availability.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>)

Tags: [availability](<https://devfeed.tech/tags/availability.md>), [cost](<https://devfeed.tech/tags/cost.md>), [search](<https://devfeed.tech/tags/search.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [vercel](<https://devfeed.tech/tags/vercel.md>)

### AI overview

Vercel Domains adds price sorting and availability filtering. Users can find lower-cost domains more easily and focus on domains that are available for purchase.

### Source excerpt

Vercel Domains now supports price sorting and availability filtering. Price sorting shows lower cost domains first, so you can quickly find a domain that fits your budget. Availability filtering moves unavailable domains to the bottom of the search results, so you can focus on domains that you can actually purchase. Try it at vercel.com/domains. Read more

## April 2026 newsletter

DevFeed: [April 2026 newsletter](<https://devfeed.tech/articles/april-2026-newsletter-4900.md>)

Original publisher: [Read original article](<https://clickhouse.com/blog/202604-newsletter>)

Author: Mark Needham

Published: 2026-04-16T15:05:56Z

Content type: article

Language: en

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

Topics: [clickhouse](<https://devfeed.tech/topics/clickhouse.md>), [real-time](<https://devfeed.tech/topics/real-time.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [Database](<https://devfeed.tech/topics/database.md>), [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [cloud-infrastructure](<https://devfeed.tech/topics/cloud-infrastructure.md>), [Compression](<https://devfeed.tech/topics/compression.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>), [WebAssembly](<https://devfeed.tech/topics/web-assembly.md>), [API keys](<https://devfeed.tech/topics/api-keys.md>), [OAuth](<https://devfeed.tech/topics/oauth.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-coding](<https://devfeed.tech/tags/agentic-coding.md>), [api](<https://devfeed.tech/tags/api.md>), [api-keys](<https://devfeed.tech/tags/api-keys.md>), [authentication](<https://devfeed.tech/tags/authentication.md>), [blockchain](<https://devfeed.tech/tags/blockchain.md>), [cli](<https://devfeed.tech/tags/cli.md>), [clickhouse](<https://devfeed.tech/tags/clickhouse.md>), [compression](<https://devfeed.tech/tags/compression.md>), [data](<https://devfeed.tech/tags/data.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [networking](<https://devfeed.tech/tags/networking.md>), [newsletter](<https://devfeed.tech/tags/newsletter.md>), [observability](<https://devfeed.tech/tags/observability.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [webassembly](<https://devfeed.tech/tags/webassembly.md>)

### AI overview

The April 2026 ClickHouse newsletter covers recent developments in real-time data warehousing, including the 26.3 release, materialized CTEs, WebAssembly UDFs, asynchronous inserts, and JOIN reordering. It also introduces clickhousectl for local and cloud management, highlights agentic coding, describes Open House 2026, and reports on faster blockchain data backfills.

### Source excerpt

Welcome to the April 2026 ClickHouse newsletter, which will round up what's happened in real-time data warehouses over the last month.

## Index-based pruning in ClickHouse

DevFeed: [Index-based pruning in ClickHouse](<https://devfeed.tech/articles/index-based-pruning-in-clickhouse-5312.md>)

Original publisher: [Read original article](<https://clickhouse.com/blog/index-based-pruning>)

Author: Mark Needham

Published: 2026-04-15T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [clickhouse](<https://devfeed.tech/topics/clickhouse.md>), [data](<https://devfeed.tech/topics/data.md>), [dataset](<https://devfeed.tech/topics/dataset.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [clickhouse](<https://devfeed.tech/tags/clickhouse.md>), [data](<https://devfeed.tech/tags/data.md>), [learn](<https://devfeed.tech/tags/learn.md>), [post](<https://devfeed.tech/tags/post.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [speed](<https://devfeed.tech/tags/speed.md>), [techniques](<https://devfeed.tech/tags/techniques.md>)

### AI overview

This tutorial explains three ClickHouse index-based pruning techniques--primary indexes, lightweight projections, and skip indexes--using a 243-million-row UK property sales dataset. It shows how sorting and alternative data layouts allow ClickHouse to skip granules and reduce the amount of data read by analytical queries.

### Source excerpt

Learn how ClickHouse uses primary indexes, lightweight projections, and skip indexes to prune data before reading it. Demonstrated on a 243 million row UK property sales dataset.

## ClickHouse Release 26.3

DevFeed: [ClickHouse Release 26.3](<https://devfeed.tech/articles/clickhouse-release-26-3-5140.md>)

Original publisher: [Read original article](<https://clickhouse.com/blog/clickhouse-release-26-03>)

Author: ClickHouse

Published: 2026-04-07T00:00:00Z

Content type: release

Language: en

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

Topics: [clickhouse](<https://devfeed.tech/topics/clickhouse.md>), [dataset](<https://devfeed.tech/topics/dataset.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>)

Tags: [clickhouse](<https://devfeed.tech/tags/clickhouse.md>), [community](<https://devfeed.tech/tags/community.md>), [contributed](<https://devfeed.tech/tags/contributed.md>), [contributors](<https://devfeed.tech/tags/contributors.md>), [features](<https://devfeed.tech/tags/features.md>), [performance](<https://devfeed.tech/tags/performance.md>), [release](<https://devfeed.tech/tags/release.md>), [sorting](<https://devfeed.tech/tags/sorting.md>)

### AI overview

ClickHouse 26.3 introduces 27 features, 40 performance optimizations, and 202 bug fixes, including default async inserts, expanded JOIN reordering, materialized CTEs, improved EXPLAIN output, and natural sorting.

### Source excerpt

ClickHouse 26.3 is here! In this release, async inserts are turned on by default, we've got more JOIN reordering, materialized CTES have arrived, and more!

## Simplify Sorted-Order Validation with Kotlin 2.4.0's New Extensions

DevFeed: [Simplify Sorted-Order Validation with Kotlin 2.4.0's New Extensions](<https://devfeed.tech/articles/simplify-sorted-order-validation-with-kotlin-2-4-0-s-new-extensions-25978.md>)

Original publisher: [Read original article](<https://navczydev.medium.com/simplify-sorted-order-validation-with-kotlin-2-4-0s-new-extensions-b48b1ac10521?source=rss-711ab22c5c77------2>)

Author: Nav Singh

Published: 2026-04-06T02:23:40Z

Content type: article

Language: en

Sources: [Nav Singh](<https://devfeed.tech/sources/stories-by-nav-singh-on-medium.md>)

Topics: [Sorting](<https://devfeed.tech/topics/sorting.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [extension property](<https://devfeed.tech/topics/extension-property.md>)

Tags: [extension](<https://devfeed.tech/tags/extension.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-beginners](<https://devfeed.tech/tags/kotlin-beginners.md>), [kotlin-standard-library](<https://devfeed.tech/tags/kotlin-standard-library.md>), [sortedlist](<https://devfeed.tech/tags/sortedlist.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [standard-library](<https://devfeed.tech/tags/standard-library.md>)

### AI overview

Kotlin 2.4.0-Beta1 adds standard-library extensions for checking whether a collection is sorted without sorting it: `isSorted()`, `isSortedDescending()`, `isSortedWith(comparator)`, `isSortedBy(selector)`, and `isSortedByDescending(selector)`. They return true when elements follow the expected order or the collection has fewer than two elements, and stop at the first out-of-order pair. The supplied excerpt gives no further implementation details.

### Source excerpt

Image generated using Perplexity Kotlin 2.4.0-Beta1 introduces a small but powerful addition to the standard library: a set of new extension functions that lets us check whether a collection is already sorted. With these extension functions, we can check whether elements have already been sorted without resorting them. New Functions .isSorted() .isSortedDescending() .isSortedWith(comparator) .isSortedBy(selector) .isSortedByDescending(selector) All of these return true if: The elements are in the expected order, or The collection has fewer than two elements.These functions are optimized -- they stop checking as soon as an unordered pair is found, so they handle large inputs efficiently.Code samplesdata class User(val name: String, val age: Int)fun main() { val numbers = listOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) println("Numbers: isSorted") println(numbers.isSorted()) // true println("Is sorted descending") println(numbers.isSortedDescending()) // false // Users list val users = listOf( User("Alice", 21), User("Balley", 34), User("Charles", 29), ) println("Users: isSorted by Age") println(users.isSortedBy(User::age)) // false val comparator = Comparator<User>{ user, user2 -> user.name.length.compareTo(user2.name.length) } println("Users: isSortedWith(comparator)") val sortedList = users.sortedWith(comparator) println("Users: Name by length ${sortedList.joinToString()}") // Output: Users: Name by length User(name=Bob, age=31), User(name=Alice, age=24), User(name=Charlie, age=29) println(sortedList.isSortedWith(comparator)) // true }References What's new in Kotlin 2.4.0-Beta1 | Kotlin

[Next page](<https://devfeed.tech/topics/sorting.md?cursor=WyIyMDI2LTA0LTA2VDAyOjIzOjQwKzAwOjAwIiwgIjUwZDcyOWMwLTI2MTAtNDE1MC04ZTQ2LWRiOTVmOTYxNGNmNyJd>)