# Queuing

Published articles for Queuing.

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

## v19.2.5 Squid released

DevFeed: [v19.2.5 Squid released](<https://devfeed.tech/articles/v19-2-5-squid-released-12341.md>)

Original publisher: [Read original article](<https://ceph.io/en/news/blog/2026/v19-2-5-squid-released/>)

Author: Yuri Weinstein

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

Content type: news

Language: en

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

Topics: [changelog](<https://devfeed.tech/topics/changelog.md>), [Amazon S3](<https://devfeed.tech/topics/amazon-s3.md>), [bug](<https://devfeed.tech/topics/bug.md>), [TLS (Transport Layer Security)](<https://devfeed.tech/topics/tls.md>), [Authentication](<https://devfeed.tech/topics/authentication.md>), [Authorization](<https://devfeed.tech/topics/authorization.md>), [SSL](<https://devfeed.tech/topics/ssl.md>)

Tags: [authentication](<https://devfeed.tech/tags/authentication.md>), [authorization](<https://devfeed.tech/tags/authorization.md>), [blog-post](<https://devfeed.tech/tags/blog-post.md>), [bug](<https://devfeed.tech/tags/bug.md>), [changelog](<https://devfeed.tech/tags/changelog.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [en-article](<https://devfeed.tech/tags/en-article.md>), [en-blog-post](<https://devfeed.tech/tags/en-blog-post.md>), [object-storage](<https://devfeed.tech/tags/object-storage.md>), [queuing](<https://devfeed.tech/tags/queuing.md>), [release](<https://devfeed.tech/tags/release.md>), [s3](<https://devfeed.tech/tags/s3.md>), [squid](<https://devfeed.tech/tags/squid.md>), [ssl](<https://devfeed.tech/tags/ssl.md>), [tls](<https://devfeed.tech/tags/tls.md>), [vector](<https://devfeed.tech/tags/vector.md>)

### AI overview

Ceph v19.2.5 Squid is the fifth backport release in the Squid series. It fixes issues across MDS, OSD, and RGW, including request queuing faults, rollback and erasure-coding behavior, TLS 1.3 cipher configuration, S3 ACL handling, multisite synchronization, policy evaluation, presigned URL authentication, object tagging, frontend concurrency, and bucket statistics.

### Source excerpt

This is the fifth backport release in the Squid series. We recommend all users update to this release. Notable Changes ¶ MDS (Metadata Server) ¶ Fixed a segmentation fault relating to MDSContext completion and request queuing. OSD (Object Storage Daemon) ¶ Rollback & Vector Fixes: Corrected rollback logic for partial write object information (OI) and optimized Erasure Coding (EC) by ensuring Twiddle creates a full-sized vector. RGW (RADOS Gateway) ¶ TLS 1.3 Ciphersuites: Introduced the ssl_ciphersuites configuration option for the Beast front-end to support TLS 1.3 cipher customizations. S3 PutObject ACLs Fix: Fixed a bug where PutObject requests were erroneously rejected under BlockPublicAcls due to an incorrect comparison return value from canned_acl.compare(). Multisite Sync Robustness: Resolved an infinite loop scenario in RGWBucketFullSyncCR when a source bucket was deleted mid-sync by introducing a mechanism to clear stateful data in reused bucket_list_result objects. SNS Policy Evaluation: Updated ListTopics to use the account root ARN for policy evaluation when invoked by a non-root account user, preventing unexpected implicit denies from identity-based policies. Presigned URLs: Fixed an internal server error occurring during the authentication process of presigned URLs. Prerequest Hook: Restructured the order of execution so that the prerequest hook now runs after the authorization process has completed. Object Tagging: Added handling for plain-text object tags during execution of RGWObjTags::decode(). Beast Frontend Stability: Applied a strand executor to the Beast timeout timer to avoid concurrent socket access and potential race conditions. Bucket Statistics: Added a fix for bucket stats execution when the underlying bucket index does not exist. Changelog ¶ [Stretch Mode] mon: restrict changing mon election strategy post stretch mode (pr#65458, Kamoltat Sirivadhna) Check if HTTP\_X\_AMZ\_COPY\_SOURCE header is empty (pr#66028, Suyash Dongre) Fix multifs

## SFQ: Simple, Stateless, Stochastic Fairness

DevFeed: [SFQ: Simple, Stateless, Stochastic Fairness](<https://devfeed.tech/articles/sfq-simple-stateless-stochastic-fairness-12589.md>)

Original publisher: [Read original article](<http://brooker.co.za/blog/2026/02/25/sfq.html>)

Author: Marc Brooker

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

Content type: opinion

Language: en

Sources: [Marc Brooker's Blog](<https://devfeed.tech/sources/marc-brooker-s-blog.md>), [Marc Brooker's Blog](<https://devfeed.tech/sources/marc-brooker-s-blog-2.md>)

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Remote Procedure Call (RPC)](<https://devfeed.tech/topics/rpc.md>), [Network](<https://devfeed.tech/topics/network.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [customer](<https://devfeed.tech/tags/customer.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [network](<https://devfeed.tech/tags/network.md>), [queuing](<https://devfeed.tech/tags/queuing.md>), [rpc](<https://devfeed.tech/tags/rpc.md>)

### AI overview

The article explains Stochastic Fairness Queuing (SFQ), an algorithm for isolating workloads from different customers and mitigating noisy-neighbor effects with O(1) queues and O(1) time. It contrasts SFQ with per-client fairness queuing, explains hash-based queue assignment and periodic hash perturbation, and discusses applying the approach to network traffic, RPC requests, single-host services, and load balancing across hosts.

### Source excerpt

SFQ: Simple, Stateless, Stochastic Fairness Roll the dice. Paul E. McKenney's 1990 paper Stochastic Fairness Queuing contains one of my favorite little algorithms for distributed systems. Stochastic Fairness Queuing is a way to stochastically isolate workloads from different customers in a way that significantly mitigates the effects of noisy neighbors, with O(1) queues and O(1) time. McKenney starts by describing Fairness Queuing (or queue per client): This fairness-queuing algorithm operates by maintaining a separate first-come-first-served (FCFS) queue for each conversation. ... Since the queues are serviced in a bit-by-bit round-robin fashion ill-behaved conversations that attempt to use more than their fair share of network resources will face longer delays and larger packet-loss rates than well-behaved conversations that remain within their fair share. That's a network packet focused view, but the same thing can apply to RPC requests, for example, just by using a different key (e.g. the authorized customer id). The big downside of this in distributed systems is that it requires O(customers) queues, and the related O(customers) work of doing round-robin across those queues. Stochastic fairness queuing can be most easily understood by comparing it to strict fairness queuing. The major differences are that the queues are serviced in strict round-robin order and that a simple hash function is used to map from source-destination address pair into a fixed set of queues. In SFQ, on the other hand, a fixed set of queues is used (so O(1) queues, not O(customers) queues), and customers are assigned to the queues based on a hash. That's great, but still causes the problem of long-term bad luck. If I end up on a queue with a noisy neighbor, I end up there forever. If two conversations collide, they will continue to collide, resulting in each conversation of the pair persistently receiving less than its share of bandwidth. This situation is deviated by periodically perturbin

## Promise queues and batching concurrent tasks in Deno

DevFeed: [Promise queues and batching concurrent tasks in Deno](<https://devfeed.tech/articles/promise-queues-and-batching-concurrent-tasks-in-deno-8056.md>)

Original publisher: [Read original article](<https://snyk.io/blog/promise-queues-concurrent-tasks-deno/>)

Author: Liran Tal

Published: 2024-09-25T04:00:00Z

Content type: tutorial

Language: en

Sources: [Blog RSS Feed | Snyk](<https://devfeed.tech/sources/blog-rss-feed-snyk.md>)

Topics: [Deno](<https://devfeed.tech/topics/deno.md>), [Promise](<https://devfeed.tech/topics/promise.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Security](<https://devfeed.tech/topics/security.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [application-security](<https://devfeed.tech/tags/application-security.md>), [batching](<https://devfeed.tech/tags/batching.md>), [blog](<https://devfeed.tech/tags/blog.md>), [code-security](<https://devfeed.tech/tags/code-security.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [developer](<https://devfeed.tech/tags/developer.md>), [java](<https://devfeed.tech/tags/java.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [memory](<https://devfeed.tech/tags/memory.md>), [performance](<https://devfeed.tech/tags/performance.md>), [queue](<https://devfeed.tech/tags/queue.md>), [queuing](<https://devfeed.tech/tags/queuing.md>), [security](<https://devfeed.tech/tags/security.md>), [snyk-apprisk](<https://devfeed.tech/tags/snyk-apprisk.md>), [snyk-code](<https://devfeed.tech/tags/snyk-code.md>)

### AI overview

This tutorial explains how Promise queues and task batching can manage concurrent asynchronous tasks in Deno more efficiently. It covers JavaScript's single-threaded, event-driven model, the limitations of running many promises together, and how queuing can reduce memory pressure and prevent one failed task from causing complete failure.

### Source excerpt

Learn how to create secure applications using Deno. Explore the default security measures provided by Deno, understand potential vulnerabilities such as Server-Side Request Forgery (SSRF), and uncover the best practices for minimizing risks. Enhance your application's security by leveraging Deno's advanced features.

## Using SQS to Throttle Writes to DynamoDB

DevFeed: [Using SQS to Throttle Writes to DynamoDB](<https://devfeed.tech/articles/using-sqs-to-throttle-writes-to-dynamodb-18018.md>)

Original publisher: [Read original article](<https://blog.guilleojeda.com/sqs-throttle-database-writes-dynamodb>)

Author: Guillermo Ojeda

Published: 2023-09-07T00:12:11Z

Content type: tutorial

Language: en

Sources: [Guille Ojeda](<https://devfeed.tech/sources/guille-ojeda.md>)

Topics: [Amazon SQS](<https://devfeed.tech/topics/amazon-sqs.md>), [Messaging](<https://devfeed.tech/topics/messaging.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [amazon-sqs](<https://devfeed.tech/tags/amazon-sqs.md>), [aws](<https://devfeed.tech/tags/aws.md>), [backend](<https://devfeed.tech/tags/backend.md>), [cache](<https://devfeed.tech/tags/cache.md>), [caching](<https://devfeed.tech/tags/caching.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [databases](<https://devfeed.tech/tags/databases.md>), [dynamodb](<https://devfeed.tech/tags/dynamodb.md>), [e-commerce](<https://devfeed.tech/tags/e-commerce.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [queue](<https://devfeed.tech/tags/queue.md>), [queuing](<https://devfeed.tech/tags/queuing.md>), [sqs](<https://devfeed.tech/tags/sqs.md>)

### AI overview

A technical article describes an e-commerce order-processing system whose DynamoDB provisioned capacity cannot keep up with sudden write traffic. It examines using Amazon SQS to queue writes and throttle database load, while noting that DynamoDB on-demand capacity is an alternative with higher stated cost.

### Source excerpt

We're running an e-commerce platform, where people publish products and other people purchase those products. Our backend has some highly scalable microservices running on well-designed Lambdas, and there's a lot of caching involved. Our order proces...

## Simple Simulations for System Builders

DevFeed: [Simple Simulations for System Builders](<https://devfeed.tech/articles/simple-simulations-for-system-builders-12518.md>)

Original publisher: [Read original article](<http://brooker.co.za/blog/2022/04/11/simulation.html>)

Author: Marc Brooker

Published: 2022-04-11T00:00:00Z

Content type: article

Language: en

Sources: [Marc Brooker's Blog](<https://devfeed.tech/sources/marc-brooker-s-blog.md>), [Marc Brooker's Blog](<https://devfeed.tech/sources/marc-brooker-s-blog-2.md>)

Topics: [Formal methods](<https://devfeed.tech/topics/formal-methods.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Simulation and Design](<https://devfeed.tech/topics/simulation-and-design.md>), [Python](<https://devfeed.tech/topics/python.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Code](<https://devfeed.tech/topics/code.md>), [Hardware](<https://devfeed.tech/topics/hardware.md>), [Network](<https://devfeed.tech/topics/network.md>), [Availability](<https://devfeed.tech/topics/availability.md>)

Tags: [availability](<https://devfeed.tech/tags/availability.md>), [cost](<https://devfeed.tech/tags/cost.md>), [customers](<https://devfeed.tech/tags/customers.md>), [formal-methods](<https://devfeed.tech/tags/formal-methods.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [latency](<https://devfeed.tech/tags/latency.md>), [model](<https://devfeed.tech/tags/model.md>), [network](<https://devfeed.tech/tags/network.md>), [prototyping](<https://devfeed.tech/tags/prototyping.md>), [python](<https://devfeed.tech/tags/python.md>), [queuing](<https://devfeed.tech/tags/queuing.md>), [scale](<https://devfeed.tech/tags/scale.md>), [simulation](<https://devfeed.tech/tags/simulation.md>), [simulator](<https://devfeed.tech/tags/simulator.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

This article explains how simple, readable simulations can help system builders investigate properties that formal methods do not directly address, such as latency, cost, hardware needs, network sensitivity, availability, and overload behavior. It presents a Python ski-lift simulator as an example and shows how a small model can produce useful, counterintuitive insights.

### Source excerpt

Simple Simulations for System Builders Even the most basic numerical methods can lead to surprising insights. It's no secret that I'm a big fan of formal methods. I use P and TLA+ often. I like these tools because they provide clear ways to communicate about even the trickiest protocols, and allow us to use computers to reason about the systems we're designing before we build them1. These tools are typically focused on safety (Nothing bad happens) and liveness (Something good happens (eventually))2. Safety and liveness are crucial properties of systems, but far from being all the properties we care about. As system designers we typically care about many other things that aren't strictly safety or liveness properties. For example: What latency can customers expect, on average and in outlier cases? What will it cost us to run this service? How do those costs scale with different usage patterns, and dimensions of load (data size, throughput, transaction rates, etc)? What type of hardware do we need for this service, and how much? How sensitive is the design to network latency or packet loss? How do availability and durability scale with the number of replicas? How will the system behave under overload? The formal tools we typically use don't do a great job of answering these questions. There are many ways to answer them, of course, from closed-form analysis3 to prototyping. One of my favorite approaches is one I call simple simulation: writing small simulators that simulate the behavior of simple models, where the code can be easily read, reviewed, and understood by people who aren't experts on simulation or numerical methods. A Quick Example If you hang around with skiers or snowboarders, you'll have heard a lot of talk over the last couple of winters about how crowded resorts have become, and how much time they now spend waiting to ride the ski lift4. Resort operators say that visits have been up only quite modestly, but skiers are seeing much longer waits. Is somebo

## Vapor: "Learn Laravel Vapor" is now available on YouTube

DevFeed: [Vapor: "Learn Laravel Vapor" is now available on YouTube](<https://devfeed.tech/articles/vapor-learn-laravel-vapor-is-now-available-on-youtube-3871.md>)

Original publisher: [Read original article](<https://laravel.com/blog/learn-laravel-vapor-is-now-available-on-youtube>)

Author: Nuno Maduro

Published: 2021-03-05T15:08:00Z

Content type: news

Language: en

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

Topics: [Vapor](<https://devfeed.tech/topics/swift-vapor.md>), [Laravel](<https://devfeed.tech/topics/laravel.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>), [PHP](<https://devfeed.tech/topics/php.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [Monitoring](<https://devfeed.tech/topics/monitoring.md>)

Tags: [caching](<https://devfeed.tech/tags/caching.md>), [databases](<https://devfeed.tech/tags/databases.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [laravel](<https://devfeed.tech/tags/laravel.md>), [learn](<https://devfeed.tech/tags/learn.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [php](<https://devfeed.tech/tags/php.md>), [queuing](<https://devfeed.tech/tags/queuing.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [youtube](<https://devfeed.tech/tags/youtube.md>)

### AI overview

The completed Learn Laravel Vapor video series is available on YouTube. Its 22 videos cover launching Laravel infrastructure on Vapor, including local development, deployments, environments, runtimes, assets, environment variables, domains, logging, debugging, caching, databases, queuing, monitoring, file uploads, pricing, and additional learning resources.

### Source excerpt

The video series "Learn Laravel Vapor" has been completed and is now available for viewing on YouTube. With 2 hours of content, our team will help you launch your Laravel infrastructure on Vapor and fall in love with the scalable simplicity of serverless.

## Surprising Economics of Load-Balanced Systems

DevFeed: [Surprising Economics of Load-Balanced Systems](<https://devfeed.tech/articles/surprising-economics-of-load-balanced-systems-12498.md>)

Original publisher: [Read original article](<http://brooker.co.za/blog/2020/08/06/erlang.html>)

Author: Marc Brooker

Published: 2020-08-06T00:00:00Z

Content type: article

Language: en

Sources: [Marc Brooker's Blog](<https://devfeed.tech/sources/marc-brooker-s-blog.md>), [Marc Brooker's Blog](<https://devfeed.tech/sources/marc-brooker-s-blog-2.md>)

Topics: [Latency](<https://devfeed.tech/topics/latency.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Server](<https://devfeed.tech/topics/server.md>), [Back end](<https://devfeed.tech/topics/backend.md>), [client](<https://devfeed.tech/topics/client.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [economics](<https://devfeed.tech/tags/economics.md>), [latency](<https://devfeed.tech/tags/latency.md>), [load-balancer](<https://devfeed.tech/tags/load-balancer.md>), [queuing](<https://devfeed.tech/tags/queuing.md>), [server](<https://devfeed.tech/tags/server.md>), [servers](<https://devfeed.tech/tags/servers.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

The article examines an M/M/c queuing system in which single-request servers sit behind a load balancer with an infinite queue. Using Erlang's C formula, it explains that increasing the number of servers while proportionally increasing load reduces queuing and causes mean client-observed latency to asymptotically approach the one-second service time.

### Source excerpt

Surprising Economics of Load-Balanced Systems The M/M/c model may not behave like you expect. I have a system with c servers, each of which can only handle a single concurrent request, and has no internal queuing. The servers sit behind a load balancer, which contains an infinite queue. An unlimited number of clients offer c * 0.8 requests per second to the load balancer on average. In other words, we increase the offered load linearly with c to keep the per-server load constant. Once a request arrives at a server, it takes one second to process, on average. How does the client-observed mean request time vary with c? Option A is that the mean latency decreases quickly, asymptotically approaching one second as c increases (in other words, the time spent in queue approaches zero). Option B is constant. Option C is a linear improvement, and D is a linear degradation in latency. Which curve do you, intuitively, think that the latency will follow? I asked my Twitter followers the same question, and got an interestingly mixed result: Breaking down the problem a bit will help figure out which is the right answer. First, names. In the terminology of queue theory, this is an M/M/c queuing system: Poisson arrival process, exponentially distributed client service time, and c backend servers. In teletraffic engineering, it's Erlang's delay system (or, because terminology is fun, M/M/n). We can use a classic result of queuing theory to analyze this system: Erlang's C formula E2,n(A), which calculates the probability that an incoming customer request is enqueued (rather than handled immediately), based on the number of servers (n aka c), and the offered traffic A. For the details, see page 194 of the Teletraffic Engineering Handbook. Here's the basic shape of the curve (using our same parameters): Follow the blue line up to half the saturation point, at 2.5 rps offered load, and see how the probability is around 13%. Now look at the purple line at half its saturation point, at 5

## Autoscaling based on request queuing

DevFeed: [Autoscaling based on request queuing](<https://devfeed.tech/articles/autoscaling-based-on-request-queuing-15539.md>)

Original publisher: [Read original article](<https://developer.squareup.com/blog/autoscaling-based-on-request-queuing>)

Author: Derek Hammer

Published: 2017-09-13T21:37:36Z

Content type: article

Language: en

Sources: [Square Corner Blog RSS Feed](<https://devfeed.tech/sources/square-corner-blog-rss-feed.md>)

Topics: [autoscaling](<https://devfeed.tech/topics/autoscaling.md>), [modern web development](<https://devfeed.tech/topics/modern-web-development.md>), [web applications](<https://devfeed.tech/topics/web-applications.md>), [Server](<https://devfeed.tech/topics/server.md>)

Tags: [apis](<https://devfeed.tech/tags/apis.md>), [autoscaling](<https://devfeed.tech/tags/autoscaling.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [queuing](<https://devfeed.tech/tags/queuing.md>), [scale](<https://devfeed.tech/tags/scale.md>), [server](<https://devfeed.tech/tags/server.md>), [web-applications](<https://devfeed.tech/tags/web-applications.md>)

### AI overview

The article explains how traffic-heavy web applications and APIs can scale vertically by adding resources and improving resource use, or horizontally by distributing the same service across multiple servers. It presents horizontal scaling as a cost-effective alternative when hardware limits are reached.

### Source excerpt

Modern web development often includes traffic-heavy web applications and APIs. These services are tasked with a double-whammy: they need to...

## Kafka, a walking skeleton

DevFeed: [Kafka, a walking skeleton](<https://devfeed.tech/articles/kafka-a-walking-skeleton-26067.md>)

Original publisher: [Read original article](<https://blog.arkey.fr/2017/04/29/kafka-a-walking-skeleton/>)

Author: brice.dutheil@gmail.com (Brice Dutheil)

Published: 2017-04-29T00:00:00Z

Content type: article

Language: fr

Sources: [The Coffee Workshop](<https://devfeed.tech/sources/the-coffee-workshop.md>)

Topics: [Kafka](<https://devfeed.tech/topics/kafka.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>), [Hadoop](<https://devfeed.tech/topics/hadoop.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [blog-post](<https://devfeed.tech/tags/blog-post.md>), [broker](<https://devfeed.tech/tags/broker.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [messages](<https://devfeed.tech/tags/messages.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [performance](<https://devfeed.tech/tags/performance.md>), [production](<https://devfeed.tech/tags/production.md>), [queuing](<https://devfeed.tech/tags/queuing.md>)

### AI overview

This French article introduces Apache Kafka through a minimal end-to-end implementation, based on Kafka 0.9. It explains Kafka's origins at LinkedIn and describes its performance, durable message retention, scalability, fault resilience, and support for queuing and publish-subscribe messaging.

### Source excerpt

Ce blog post est une republication de mon article sur Kafka parut dans le magazine Programmez numéro 196 en mai 2016 (pages 70-73). Il se base sur la version 0.9 de Kafka.

## Big Changes and Bootcamp Updates

DevFeed: [Big Changes and Bootcamp Updates](<https://devfeed.tech/articles/big-changes-and-bootcamp-updates-19216.md>)

Original publisher: [Read original article](<https://www.codenameone.com/blog/big-changes-bootcamp-updates/>)

Author: Shai Almog

Published: 2017-04-10T00:00:00Z

Content type: article

Language: en

Sources: [CodeName One](<https://devfeed.tech/sources/codename-one.md>)

Topics: [Bootcamp](<https://devfeed.tech/topics/bootcamp.md>), [build times](<https://devfeed.tech/topics/build-times.md>), [build performance](<https://devfeed.tech/topics/build-performance.md>), [datacenter](<https://devfeed.tech/topics/datacenter.md>), [Xcode](<https://devfeed.tech/topics/xcode.md>)

Tags: [build](<https://devfeed.tech/tags/build.md>), [build-times](<https://devfeed.tech/tags/build-times.md>), [developer](<https://devfeed.tech/tags/developer.md>), [queuing](<https://devfeed.tech/tags/queuing.md>), [servers](<https://devfeed.tech/tags/servers.md>), [timeout](<https://devfeed.tech/tags/timeout.md>), [xcode](<https://devfeed.tech/tags/xcode.md>)

### AI overview

A developer update discusses heavy workloads on Mac build servers, long build times, queueing problems, timeout limits introduced during a traffic surge, and a deployed build-process improvement intended to speed up affected builds. The change may affect some native code that relies on headers included by VM-generated code.

### Source excerpt

Since I haven't blogged in a while a lot of stuff has piled up on my desk and I'll get it out in batches in this post I'll go over a few of the bigger changes we did while I was away on the bootcamp and also give you a bit of an update on what we've been doing within the bootcamp itself. The week before we launched the bootcamp our Mac build servers reached a very heavy workload, this was becoming disruptive to our general developer population as builds got queued at a high rate. After a bit of investigation it seems that this could usually be pinned to specific users with very long build times.

## SATA AHCI Driver GSoC - Update

DevFeed: [SATA AHCI Driver GSoC - Update](<https://devfeed.tech/articles/sata-ahci-driver-gsoc-update-33012.md>)

Original publisher: [Read original article](<https://reactos.org/blogs/sata-ahci-driver-gsoc-update/>)

Published: 2016-07-25T00:00:00Z

Content type: article

Language: en

Sources: [Front Page on ReactOS Website](<https://devfeed.tech/sources/front-page-on-reactos-website.md>)

Topics: [Windows](<https://devfeed.tech/topics/windows.md>), [x86](<https://devfeed.tech/topics/x86.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [Server](<https://devfeed.tech/topics/server.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [driver](<https://devfeed.tech/tags/driver.md>), [free](<https://devfeed.tech/tags/free.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [os](<https://devfeed.tech/tags/os.md>), [queuing](<https://devfeed.tech/tags/queuing.md>), [react](<https://devfeed.tech/tags/react.md>), [reactos](<https://devfeed.tech/tags/reactos.md>), [testing](<https://devfeed.tech/tags/testing.md>), [update](<https://devfeed.tech/tags/update.md>), [virtual](<https://devfeed.tech/tags/virtual.md>), [vmware](<https://devfeed.tech/tags/vmware.md>), [win32](<https://devfeed.tech/tags/win32.md>), [winapi](<https://devfeed.tech/tags/winapi.md>), [windows](<https://devfeed.tech/tags/windows.md>), [x86](<https://devfeed.tech/tags/x86.md>)

### AI overview

This update reports progress on a SATA AHCI driver tested in a VMware virtual machine running Windows Server 2003 x86. It describes supported device and read-request functionality, while noting limitations around filesystem detection and write requests.

### Source excerpt

Links Short Brief Driver Testing Why no blog? Known Issues Short Brief Supported Features: Device Adapter Detection Non-Fatal Error Handling Adapter Srb PNP Request SCSIOP_INQUIRY : Device Inquiry SCSIOP_REPORT_LUNS : Report LUN SCSIOP_READ_CAPACITY : Device Geometry SCSIOP_TEST_UNIT_READY SCSIOP_READ : Device Read Request UnSupported Features: Fatal Error Handling SCSIOP_MODE_SENSE SCSIOP_WRITE NCQ : Native Command Queuing Cache and Priority Requests Driver Testing Platform: Virtual Machine (Vmware) Operating System: Windows Server 2003 x86 Free Build

## Applying Back Pressure When Overloaded

DevFeed: [Applying Back Pressure When Overloaded](<https://devfeed.tech/articles/applying-back-pressure-when-overloaded-13625.md>)

Original publisher: [Read original article](<https://mechanical-sympathy.blogspot.com/2012/05/apply-back-pressure-when-overloaded.html>)

Author: Martin Thompson (noreply@blogger.com)

Published: 2012-05-19T21:17:00Z

Content type: article

Language: en

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

Topics: [systems](<https://devfeed.tech/topics/systems.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Latency](<https://devfeed.tech/topics/latency.md>)

Tags: [capacity](<https://devfeed.tech/tags/capacity.md>), [java](<https://devfeed.tech/tags/java.md>), [latency](<https://devfeed.tech/tags/latency.md>), [low-latency](<https://devfeed.tech/tags/low-latency.md>), [performance](<https://devfeed.tech/tags/performance.md>), [queuing](<https://devfeed.tech/tags/queuing.md>), [systems](<https://devfeed.tech/tags/systems.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

The article explains how systems under sustained load can use back pressure to maintain throughput and acceptable response times by rejecting requests beyond processing capacity. It warns that unbounded queues increase latency and can consume all available memory, causing system failure.

### Source excerpt

How should a system respond when under sustained load? Should it keep accepting requests until its response times follow the deadly hockey stick, followed by a crash? All too often this is what happens unless a system is designed to cope with the case of more requests arriving than it is capable of processing. If we are seeing a sustained arrival rate of requests, greater than our system is capable of processing, then something has to give. Having the entire system degrade is not the ideal service we want to give our customers. A better approach would be to process transactions at our systems maximum possible throughput rate, while maintaining a good response time, and rejecting requests above this arrival rate. Let's consider a small art gallery as an metaphor. In this gallery the typical viewer spends on average 20 minutes browsing, and the gallery can hold a maximum of 30 viewers. If more than 30 viewers occupy the gallery at the same time then customers become unhappy because they cannot have a clear view of the paintings. If this happens they are unlikely to purchase or return. To keep our viewers happy it is better to recommend that some viewers visit the café a few doors down and come back when the gallery is less busy. This way the viewers in the gallery get to see all the paintings without other viewers in the way, and in the meantime those we cannot accommodate enjoy a coffee. If we apply Little's Law we cannot have customers arriving at more than 90 per hour, otherwise the maximum capacity is exceeded. If between 9:00-10:00 they are arriving at 100 per hour, then I'm sure the café down the road will appreciate the extra 10 customers. Within our systems the available capacity is generally a function of the size of our thread pools and time to process individual transactions. These thread pools are usually fronted by queues to handle bursts of traffic above our maximum arrival rate. If the queues are unbounded, and we have a sustained arrival rate above the