# cycles

Published articles for cycles.

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

## Benchmarking memory-level parallelism across AMD, Intel, and Graviton processors

DevFeed: [Benchmarking memory-level parallelism across AMD, Intel, and Graviton processors](<https://devfeed.tech/articles/memory-level-parallelism-amd-is-the-king-29418.md>)

Original publisher: [Read original article](<https://lemire.me/blog/2026/07/25/memory-level-parallelism-amd-is-the-king/>)

Author: Daniel Lemire

Published: 2026-07-25T15:07:52Z

Content type: article

Language: en

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

Topics: [cpu](<https://devfeed.tech/topics/cpu.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [Intel Core](<https://devfeed.tech/topics/intel-core.md>), [Graviton](<https://devfeed.tech/topics/graviton.md>)

Tags: [benchmark](<https://devfeed.tech/tags/benchmark.md>), [core](<https://devfeed.tech/tags/core.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [graviton](<https://devfeed.tech/tags/graviton.md>), [intel](<https://devfeed.tech/tags/intel.md>), [intel-core](<https://devfeed.tech/tags/intel-core.md>), [latency](<https://devfeed.tech/tags/latency.md>), [memory](<https://devfeed.tech/tags/memory.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

This article explains memory-level parallelism, the number of memory requests a processor core can keep in flight, and measures it with a pointer-chasing benchmark. Experiments on AWS compare how this capability evolved across Intel, AMD, and Graviton processors; the supplied evidence reports AMD reaching 58 concurrent cache lines on Turin.

### Source excerpt

When your program asks for memory that is not in cache, the processor has to go to RAM. That trip costs on the order of 100 nanoseconds. On a 3 GHz core, that is about 300 cycles of doing nothing. Memory latency has not improved in ten years. The 2016 Broadwell answers a random access ... Continue reading Memory-level parallelism: AMD is the king

## How Redpanda Cloud Topics rethinks Kafka compaction

DevFeed: [How Redpanda Cloud Topics rethinks Kafka compaction](<https://devfeed.tech/articles/how-redpanda-cloud-topics-rethinks-kafka-compaction-12705.md>)

Original publisher: [Read original article](<https://www.redpanda.com/blog/how-redpanda-cloud-topics-rethinks-kafka-compaction>)

Author: Willem Kaufmann

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

Content type: article

Language: en

Sources: [Redpanda](<https://devfeed.tech/sources/redpanda.md>)

Topics: [Kafka](<https://devfeed.tech/topics/kafka.md>), [cloud-infrastructure](<https://devfeed.tech/topics/cloud-infrastructure.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [Streaming](<https://devfeed.tech/topics/streaming.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>)

Tags: [apache](<https://devfeed.tech/tags/apache.md>), [apache-kafka](<https://devfeed.tech/tags/apache-kafka.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [cloud-native](<https://devfeed.tech/tags/cloud-native.md>), [cloud-storage](<https://devfeed.tech/tags/cloud-storage.md>), [clusters](<https://devfeed.tech/tags/clusters.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [object-storage](<https://devfeed.tech/tags/object-storage.md>), [reduce](<https://devfeed.tech/tags/reduce.md>), [retention](<https://devfeed.tech/tags/retention.md>), [scale](<https://devfeed.tech/tags/scale.md>), [storage](<https://devfeed.tech/tags/storage.md>), [streaming](<https://devfeed.tech/tags/streaming.md>)

### AI overview

The article explains how Redpanda Cloud Topics redesigns Kafka log compaction for cloud-native streaming. It describes how the architecture reduces redundant processing and CPU use, lowers cloud storage costs, and preserves Kafka behavior while addressing scaling challenges such as limited memory, tombstone removal, and rewriting large volumes of object storage data.

### Source excerpt

Compaction can overwhelm poorly sized Kafka clusters, leading to full disks and maxed-out CPUs. Learn how Redpanda's Cloud Topics architecture redesigns compaction to cut redundant work, reduce cloud storage costs, and preserve the Kafka semantics you rely on.

## How to Write to SSDs - Co-Designing DBMS and Flash Storage

DevFeed: [How to Write to SSDs - Co-Designing DBMS and Flash Storage](<https://devfeed.tech/articles/how-to-write-to-ssds-co-designing-dbms-and-flash-storage-39661.md>)

Original publisher: [Read original article](<https://www.gauravsarma.com/posts/2026-06-22_optimising-ssd-writes-for-dbms>)

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

Content type: article

Language: en

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

Topics: [Database](<https://devfeed.tech/topics/database.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [systems](<https://devfeed.tech/topics/systems.md>), [optimize](<https://devfeed.tech/topics/optimize.md>), [Parallelism](<https://devfeed.tech/topics/parallelism.md>)

Tags: [b-tree](<https://devfeed.tech/tags/b-tree.md>), [checkpoint](<https://devfeed.tech/tags/checkpoint.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [database](<https://devfeed.tech/tags/database.md>), [databases](<https://devfeed.tech/tags/databases.md>), [latency](<https://devfeed.tech/tags/latency.md>), [mysql](<https://devfeed.tech/tags/mysql.md>), [optimize](<https://devfeed.tech/tags/optimize.md>), [optimizing](<https://devfeed.tech/tags/optimizing.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [ssd](<https://devfeed.tech/tags/ssd.md>), [storage](<https://devfeed.tech/tags/storage.md>), [systems](<https://devfeed.tech/tags/systems.md>), [wal](<https://devfeed.tech/tags/wal.md>), [write-amplification](<https://devfeed.tech/tags/write-amplification.md>)

### AI overview

The article explains how database management systems and SSDs jointly amplify writes. It reports that a 4 KiB logical page write can become about 18.85 KiB of flash writes on a Samsung PM9A3, and presents DBMS-SSD co-design, including avoiding in-place updates, as a way to address the combined amplification.

### Source excerpt

. [How to Write to SSDs](optimising-ssd-writes-for-dbms-cover...

## Cycles Texture Cache

DevFeed: [Cycles Texture Cache](<https://devfeed.tech/articles/cycles-texture-cache-19184.md>)

Original publisher: [Read original article](<https://code.blender.org/2026/05/cycles-texture-cache/>)

Author: Brecht Van Lommel

Published: 2026-05-01T11:50:44Z

Content type: tutorial

Language: en

Sources: [Blender](<https://devfeed.tech/sources/blender.md>)

Topics: [Caching](<https://devfeed.tech/topics/caching.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [cpu](<https://devfeed.tech/topics/cpu.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [Hardware](<https://devfeed.tech/topics/hardware.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>)

Tags: [benchmark](<https://devfeed.tech/tags/benchmark.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [general-development](<https://devfeed.tech/tags/general-development.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [memory](<https://devfeed.tech/tags/memory.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

Blender 5.2 LTS introduces a Cycles texture cache that loads only the image tiles and resolutions needed for rendering, improving memory efficiency for scenes with many image textures. The article explains how to enable and generate texture cache files, viewport texture-resolution controls, and CPU/GPU implementation considerations.

### Source excerpt

In Blender 5.2 LTS, rendering scenes with many image textures will become much more memory efficient.

## Branch Prediction: Why an if Inside a Hot Loop Costs Milliseconds

DevFeed: [Branch Prediction: Why an if Inside a Hot Loop Costs Milliseconds](<https://devfeed.tech/articles/branch-prediction-why-an-if-inside-a-hot-loop-costs-milliseconds-39571.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/19-branch-prediction-loop-unrolling/>)

Author: hello@ankit-rana.com

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

Content type: tutorial

Language: en

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

Topics: [cpu](<https://devfeed.tech/topics/cpu.md>), [Hardware](<https://devfeed.tech/topics/hardware.md>)

Tags: [branch](<https://devfeed.tech/tags/branch.md>), [branch-prediction](<https://devfeed.tech/tags/branch-prediction.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [loops](<https://devfeed.tech/tags/loops.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [performance](<https://devfeed.tech/tags/performance.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [pipelining](<https://devfeed.tech/tags/pipelining.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [systems](<https://devfeed.tech/tags/systems.md>), [wall-clock-time](<https://devfeed.tech/tags/wall-clock-time.md>)

### AI overview

This tutorial explains how CPU pipelining and branch prediction affect performance in hot loops. It describes the cost of mispredictions and suggests sorting data to create predictable branch patterns or using branchless techniques and loop unrolling, while recommending measurement on the target workload.

### Source excerpt

CPUs pipeline instructions and speculate on branch outcomes. A misprediction discards the speculative work and flushes the pipeline at roughly 10 to 20 cycles. In a million-iteration loop with random branch outcomes, those flushes dominate runtime. Sorting the data so the branch resolves the same way for long runs, or removing the branch entirely with a mask or 0/1 multiplier, is what recovers the time.

## The Agentic OODA Loop: How AI and Humans Learn to Defend Together

DevFeed: [The Agentic OODA Loop: How AI and Humans Learn to Defend Together](<https://devfeed.tech/articles/the-agentic-ooda-loop-how-ai-and-humans-learn-to-defend-together-7799.md>)

Original publisher: [Read original article](<https://snyk.io/blog/agentic-ooda-loop/>)

Author: Manoj Nair

Published: 2025-11-10T05:00:00Z

Content type: article

Language: en

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

Topics: [Securing AI](<https://devfeed.tech/topics/securing-ai.md>), [ai security](<https://devfeed.tech/topics/ai-security.md>), [Security](<https://devfeed.tech/topics/security.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-security](<https://devfeed.tech/tags/agentic-security.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [autonomous-agents](<https://devfeed.tech/tags/autonomous-agents.md>), [awareness](<https://devfeed.tech/tags/awareness.md>), [blog](<https://devfeed.tech/tags/blog.md>), [collaboration](<https://devfeed.tech/tags/collaboration.md>), [context](<https://devfeed.tech/tags/context.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [executive](<https://devfeed.tech/tags/executive.md>), [false-positive](<https://devfeed.tech/tags/false-positive.md>), [loops](<https://devfeed.tech/tags/loops.md>), [model](<https://devfeed.tech/tags/model.md>), [pmm](<https://devfeed.tech/tags/pmm.md>), [policy](<https://devfeed.tech/tags/policy.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [security](<https://devfeed.tech/tags/security.md>), [systems](<https://devfeed.tech/tags/systems.md>), [visibility](<https://devfeed.tech/tags/visibility.md>)

### AI overview

This article presents the Agentic OODA Loop as a model for human and AI security engineers to defend AI-native systems. Inspired by the fighter-pilot cycle of Observe, Orient, Decide, and Act, it advocates adaptive defense that gains real-time visibility, reasons about context, automates policy enforcement and remediation with human oversight, and continuously learns from alerts, false positives, and exploit attempts.

### Source excerpt

Discover how AI and human security engineers collaborate to defend against evolving threats at machine speed. Learn about the new mindset for adaptive, intelligent, and symbiotic defense in the age of Agentic AI.

## Underrust: What is the cost of Mutex, RwLock and AtomicPtr?

DevFeed: [Underrust: What is the cost of Mutex, RwLock and AtomicPtr?](<https://devfeed.tech/articles/underrust-what-is-the-cost-of-mutex-rwlock-and-atomicptr-35479.md>)

Original publisher: [Read original article](<https://darkcoding.net/software/underrust-mutual-exclusion/>)

Author: Graham King

Published: 2025-05-05T20:05:00Z

Content type: tutorial

Language: en

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

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [x86](<https://devfeed.tech/topics/x86.md>), [cpu](<https://devfeed.tech/topics/cpu.md>), [Assembly](<https://devfeed.tech/topics/assembly.md>)

Tags: [assembly](<https://devfeed.tech/tags/assembly.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [locking](<https://devfeed.tech/tags/locking.md>), [performance](<https://devfeed.tech/tags/performance.md>), [rust](<https://devfeed.tech/tags/rust.md>), [software](<https://devfeed.tech/tags/software.md>), [synchronization](<https://devfeed.tech/tags/synchronization.md>), [underrust](<https://devfeed.tech/tags/underrust.md>)

### AI overview

A Rust-focused analysis uses assembly output to examine the cost of Mutex, RwLock, and atomic operations for many concurrent readers and an occasional writer. It scopes the discussion to Linux and x86, noting that the fast-path operations discussed are roughly in the range of 20 to 30 CPU cycles.

### Source excerpt

With many concurrent readers and a single occasional writer, which mutual exclusion primitive should you use? Let's look at the assembly to find out.

## Use BGP Outbound Route Filters (ORF) for IP Prefixes

DevFeed: [Use BGP Outbound Route Filters (ORF) for IP Prefixes](<https://devfeed.tech/articles/use-bgp-outbound-route-filters-orf-for-ip-prefixes-11114.md>)

Original publisher: [Read original article](<https://blog.ipspace.net/2025/01/bgp-labs-orf/>)

Published: 2025-01-24T07:11:00Z

Content type: tutorial

Language: en

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

Topics: [BGP](<https://devfeed.tech/topics/bgp.md>), [browser](<https://devfeed.tech/topics/browser.md>), [GitHub](<https://devfeed.tech/topics/github.md>)

Tags: [bgp](<https://devfeed.tech/tags/bgp.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [filter](<https://devfeed.tech/tags/filter.md>), [ip](<https://devfeed.tech/tags/ip.md>), [mpls](<https://devfeed.tech/tags/mpls.md>), [netlab](<https://devfeed.tech/tags/netlab.md>), [route](<https://devfeed.tech/tags/route.md>)

### AI overview

This tutorial explains how BGP Outbound Route Filters (ORF) for IP prefixes can reduce unnecessary BGP updates and CPU use compared with inbound filtering. It points readers to a practical lab exercise using a browser-based GitHub Codespace and netlab.

### Source excerpt

When a BGP router cannot fit the whole BGP table into its forwarding table (FIB), we often use inbound filters to limit the amount of information the device keeps in its BGP table. That's usually a waste of resources: The BGP neighbor has to send information about all prefixes in its BGP table The device with an inbound filter wastes additional CPU cycles to drop many incoming updates. Wouldn't it be better for the device with an inbound filter to push that filter to its BGP neighbors? Read more ...

## ethereum.org Cycle 1 Roadmap Adopts Six-Week Shape Up Development Cycles

DevFeed: [ethereum.org Cycle 1 Roadmap Adopts Six-Week Shape Up Development Cycles](<https://devfeed.tech/articles/from-quarters-to-cycles-accelerating-ethereum-org-17132.md>)

Original publisher: [Read original article](<https://blog.ethereum.org/en/2025/01/23/cycle-1-ethereum-org>)

Author: Digital Studio

Published: 2025-01-23T00:00:00Z

Content type: article

Language: en

Sources: [Ethereum Foundation Blog](<https://devfeed.tech/sources/ethereum-foundation-blog.md>)

Topics: [Website](<https://devfeed.tech/topics/website.md>), [Development](<https://devfeed.tech/topics/development.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>), [ui](<https://devfeed.tech/topics/ui.md>), [Shadcn UI](<https://devfeed.tech/topics/shadcn-ui.md>), [web design](<https://devfeed.tech/topics/web-design.md>)

Tags: [cycles](<https://devfeed.tech/tags/cycles.md>), [design](<https://devfeed.tech/tags/design.md>), [development](<https://devfeed.tech/tags/development.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [ethereum-org](<https://devfeed.tech/tags/ethereum-org.md>), [shadcn-ui](<https://devfeed.tech/tags/shadcn-ui.md>), [ui](<https://devfeed.tech/tags/ui.md>), [ui-components](<https://devfeed.tech/tags/ui-components.md>), [web-design](<https://devfeed.tech/tags/web-design.md>), [website-design](<https://devfeed.tech/tags/website-design.md>)

### AI overview

ethereum.org describes its first Shape Up cycle, using six-week build periods followed by two-week cooldowns. The roadmap covers interactive educational content, audio support, native Web3 features, documentation updates, translation improvements, Shadcn UI migration, server components, and related ecosystem projects.

### Source excerpt

We're evolving how we build ethereum.org. Starting January 20th, we've adopted Shape Up cycles - focused 6-week build periods followed by 2-week cooldowns. For Cycle 1, each project below will ship by the end of February - no automatic rollovers to next cycle. Quick point of clarification: this is...

## Spotlight on SIG Architecture: Code Organization

DevFeed: [Spotlight on SIG Architecture: Code Organization](<https://devfeed.tech/articles/spotlight-on-sig-architecture-code-organization-17577.md>)

Original publisher: [Read original article](<https://www.kubernetes.dev/blog/2024/04/11/sig-architecture-code-spotlight-2024/>)

Author: The Kubernetes Authors

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

Content type: article

Language: en

Sources: [Kubernetes Contributors Blog](<https://devfeed.tech/sources/kubernetes-contributors-blog.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [Dependency management](<https://devfeed.tech/topics/dependency-management.md>), [GitHub](<https://devfeed.tech/topics/github.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [code](<https://devfeed.tech/tags/code.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [dependency-management](<https://devfeed.tech/tags/dependency-management.md>), [github](<https://devfeed.tech/tags/github.md>), [go](<https://devfeed.tech/tags/go.md>), [interview](<https://devfeed.tech/tags/interview.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [series](<https://devfeed.tech/tags/series.md>), [technical](<https://devfeed.tech/tags/technical.md>), [vmware](<https://devfeed.tech/tags/vmware.md>)

### AI overview

An interview in the SIG Architecture Spotlight series examines Kubernetes code organization. It discusses the scale of the Kubernetes Go codebase, dependency management, publishing Go modules, and using a monorepo with downstream repositories.

### Source excerpt

This is the third interview of a SIG Architecture Spotlight series that will cover the different subprojects. We will cover SIG Architecture: Code Organization . In this SIG Architecture spotlight I talked with Madhav Jivrajani (VMware), a member of the Code Organization subproject. Introducing the Code Organization subproject Frederico (FSM): Hello Madhav, thank you for your availability. Could you start by telling us a bit about yourself, your role and how you got involved in Kubernetes? Madhav Jivrajani (MJ): Hello! My name is Madhav Jivrajani, I serve as a technical lead for SIG Contributor Experience and a GitHub Admin for the Kubernetes project. Apart from that I also contribute to SIG API Machinery and SIG Etcd, but more recently, I've been helping out with the work that is needed to help Kubernetes stay on supported versions of Go , and it is through this that I am involved with the Code Organization subproject of SIG Architecture. FSM: A project the size of Kubernetes must have unique challenges in terms of code organization - is this a fair assumption? If so, what would you pick as some of the main challenges that are specific to Kubernetes? MJ: That's a fair assumption! The first interesting challenge comes from the sheer size of the Kubernetes codebase. We have ≅2.2 million lines of Go code (which is steadily decreasing thanks to dims and other folks in this sub-project!), and a little over 240 dependencies that we rely on either directly or indirectly, which is why having a sub-project dedicated to helping out with dependency management is crucial: we need to know what dependencies we're pulling in, what versions these dependencies are at, and tooling to help make sure we are managing these dependencies across different parts of the codebase in a consistent manner. Another interesting challenge with Kubernetes is that we publish a lot of Go modules as part of the Kubernetes release cycles, one example of this is client-go .However, we as a project would

## Can We Skip the Network Layer?

DevFeed: [Can We Skip the Network Layer?](<https://devfeed.tech/articles/can-we-skip-the-network-layer-10950.md>)

Original publisher: [Read original article](<https://blog.ipspace.net/2024/02/skip-network-layer/>)

Published: 2024-02-12T09:52:00Z

Content type: article

Language: en

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

Topics: [Network](<https://devfeed.tech/topics/network.md>), [Ethernet](<https://devfeed.tech/topics/ethernet.md>), [Protocol (disambiguation)](<https://devfeed.tech/topics/protocol.md>), [Terminal](<https://devfeed.tech/topics/terminal.md>)

Tags: [boot](<https://devfeed.tech/tags/boot.md>), [bridging](<https://devfeed.tech/tags/bridging.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [digital](<https://devfeed.tech/tags/digital.md>), [ethernet](<https://devfeed.tech/tags/ethernet.md>), [memory](<https://devfeed.tech/tags/memory.md>), [network](<https://devfeed.tech/tags/network.md>), [networking-fundamentals](<https://devfeed.tech/tags/networking-fundamentals.md>), [physics](<https://devfeed.tech/tags/physics.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [run](<https://devfeed.tech/tags/run.md>)

### AI overview

The article examines proposals to omit network-layer addressing from local solutions by using Ethernet data-link addresses with transport protocols directly above them. It recounts how DEC's LAT and MOP protocols placed local terminal services over Ethernet, and explains how requirements spanning multiple Ethernet segments exposed the approach's limitations and led to transparent bridging.

### Source excerpt

I mentioned that you don't need node addresses when dealing with only two entities. Now and then, someone tries to extend this concept and suggests that the network layer addressing isn't needed if the solution is local. For instance, if we have a solution that is supposed to run only on a single Ethernet segment, we don't need network layer addressing because we already have data link layer addresses required for Ethernet to work (see also: ATAoE). Too often in the past, an overly ingenious engineer or programmer got the idea to simplify everyone's life and use the data link layer addresses as the ultimate addresses of individual nodes. They would then put the transport layer on top of that to get reliable packet transport. Finally, put whatever application on top of the transport layer. Problem solved. Read more ...

## Locking Xcode versions in bazel

DevFeed: [Locking Xcode versions in bazel](<https://devfeed.tech/articles/locking-xcode-versions-in-bazel-25403.md>)

Original publisher: [Read original article](<https://smileykeith.com/2021/03/08/locking-xcode-in-bazel/>)

Author: Keith Smiley

Published: 2021-03-08T16:40:00Z

Content type: article

Language: en

Sources: [Keith Smiley](<https://devfeed.tech/sources/keith-smiley.md>)

Topics: [Xcode](<https://devfeed.tech/topics/xcode.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [macOS](<https://devfeed.tech/topics/macos.md>), [iOS](<https://devfeed.tech/topics/ios.md>), [SDK](<https://devfeed.tech/topics/sdk.md>)

Tags: [bazel](<https://devfeed.tech/tags/bazel.md>), [cache](<https://devfeed.tech/tags/cache.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [ios](<https://devfeed.tech/tags/ios.md>), [macos](<https://devfeed.tech/tags/macos.md>), [sdk](<https://devfeed.tech/tags/sdk.md>), [watchos](<https://devfeed.tech/tags/watchos.md>), [xcode](<https://devfeed.tech/tags/xcode.md>)

### AI overview

This article explains how to lock supported Xcode versions in Bazel so team members can share remote build-cache artifacts reliably. It describes replacing Bazel's automatic Xcode discovery with a project-managed configuration and supporting multiple Xcode versions using build numbers.

### Source excerpt

When using bazel on a team, one of the things you quickly want to do is stand up a remote cache. This allows bazel to download build artifacts instead of spending CPU cycles reproducing things that have already been built by someone else. In order for bazel to guarantee that downloading the artifacts instead of building them will produce the same results, it must ensure that all the inputs of your build are the same as a previous build.1 For macOS and iOS builds bazel's inputs include the version of Xcode you're using. This means if developers on your team use different versions of Xcode, they cannot share the same build cache. Bazel discovers your currently installed Xcode versions by running xcode_locator, and then generating a BUILD file that contains an entry for every version you currently have installed. The result looks something like this:2 load("@apple_support//xcode:xcode_config.bzl", "xcode_config") load("@apple_support//xcode:xcode_version.bzl", "xcode_version") xcode_version( name = "version12_4_0_12D4e", version = "12.4.0.12D4e", aliases = ["12.4.0", "12.4", "12.4.0.12D4e"], default_ios_sdk_version = "14.4", default_tvos_sdk_version = "14.3", default_macos_sdk_version = "11.1", default_watchos_sdk_version = "7.2", ) xcode_version( name = "version12_2_0_12B45b", version = "12.2.0.12B45b", aliases = ["12.2.0", "12", "12.2", "12.2.0.12B45b"], default_ios_sdk_version = "14.2", default_tvos_sdk_version = "14.2", default_macos_sdk_version = "11.0", default_watchos_sdk_version = "7.1", ) xcode_config( name = "host_xcodes", versions = [":version12_4_0_12D4e", ":version12_2_0_12B45b"], default = ":version12_4_0_12D4e", ) To fetch the contents of this file on your machine you can run: cat bazel-$(basename $PWD)/external/local_config_xcode/BUILD In order to enforce developers use the same version, you can short circuit bazel's Xcode discovery and instead reference a local target that you provide.3 To do this, you can setup your target in the BUILD file at the roo

## Swift Closures in Kotlin Multiplatform - Ben Whitley

DevFeed: [Swift Closures in Kotlin Multiplatform - Ben Whitley](<https://devfeed.tech/articles/swift-closures-in-kotlin-multiplatform-ben-whitley-38323.md>)

Original publisher: [Read original article](<https://touchlab.co/swift-closures-kotlin-multiplatform>)

Published: 2020-06-11T19:11:25Z

Content type: tutorial

Language: en

Sources: [Touchlab | Enterprise Mobile Innovation & Development](<https://devfeed.tech/sources/touchlab-enterprise-mobile-innovation-development.md>)

Topics: [Kotlin Multiplatform](<https://devfeed.tech/topics/kotlin-multiplatform.md>), [Closure](<https://devfeed.tech/topics/closure.md>), [Swift](<https://devfeed.tech/topics/swift.md>), [iOS](<https://devfeed.tech/topics/ios.md>), [ui](<https://devfeed.tech/topics/ui.md>)

Tags: [closure](<https://devfeed.tech/tags/closure.md>), [code-sharing](<https://devfeed.tech/tags/code-sharing.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [ios](<https://devfeed.tech/tags/ios.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [swift](<https://devfeed.tech/tags/swift.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

This tutorial explains how Swift closures are used on the iOS side of Kotlin Multiplatform projects and how they can create strong reference cycles. It describes how Automatic Reference Counting manages memory and why weak references to self may be needed when a closure captures a ViewController.

### Source excerpt

When working on the iOS side of Kotlin Multiplatform, it's helpful to understand Swift closures to update UI and avoid strong reference cycles.

## How to Package a SaaS Application for On-Premises Deployment

DevFeed: [How to Package a SaaS Application for On-Premises Deployment](<https://devfeed.tech/articles/how-to-package-saas-application-29810.md>)

Original publisher: [Read original article](<https://goteleport.com/blog/saas-to-onprem-considerations/>)

Author: info@goteleport.com (Jordan Marin)

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

Content type: tutorial

Language: en

Sources: [Teleport](<https://devfeed.tech/sources/teleport.md>)

Topics: [on-prem](<https://devfeed.tech/topics/on-prem.md>), [Software as a service](<https://devfeed.tech/topics/saas.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [cloud-infrastructure](<https://devfeed.tech/topics/cloud-infrastructure.md>), [releases](<https://devfeed.tech/topics/releases.md>), [audit](<https://devfeed.tech/topics/audit.md>)

Tags: [cloud](<https://devfeed.tech/tags/cloud.md>), [compliance](<https://devfeed.tech/tags/compliance.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [on-prem](<https://devfeed.tech/tags/on-prem.md>), [patches](<https://devfeed.tech/tags/patches.md>), [saas](<https://devfeed.tech/tags/saas.md>)

### AI overview

The article explains why SaaS providers may need to offer on-premises deployment and what changes when packaging software for customer-managed environments. It highlights portability across locations and infrastructure, while emphasizing governance, update cycles, product roadmaps, release schedules, dependency management, and compliance support.

### Source excerpt

The public cloud is a solution for many customer workloads but not for all. Teleport's insight into what it means moving from SaaS to on-prem.

## Stack Overflow: How We Do App Caching - 2019 Edition

DevFeed: [Stack Overflow: How We Do App Caching - 2019 Edition](<https://devfeed.tech/articles/stack-overflow-how-we-do-app-caching-2019-edition-21595.md>)

Original publisher: [Read original article](<https://nickcraver.com/blog/2019/08/06/stack-overflow-how-we-do-app-caching/>)

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

Content type: tutorial

Language: en

Sources: [Nick Craver](<https://devfeed.tech/sources/nick-craver.md>)

Topics: [Caching](<https://devfeed.tech/topics/caching.md>), [Stack Overflow](<https://devfeed.tech/topics/stackoverflow.md>), [App](<https://devfeed.tech/topics/app.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [API](<https://devfeed.tech/topics/api.md>), [cpu](<https://devfeed.tech/topics/cpu.md>), [Database](<https://devfeed.tech/topics/database.md>), [Web](<https://devfeed.tech/topics/web.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [app](<https://devfeed.tech/tags/app.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [blog](<https://devfeed.tech/tags/blog.md>), [cache](<https://devfeed.tech/tags/cache.md>), [caching](<https://devfeed.tech/tags/caching.md>), [computer](<https://devfeed.tech/tags/computer.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [database](<https://devfeed.tech/tags/database.md>), [latency](<https://devfeed.tech/tags/latency.md>), [memory](<https://devfeed.tech/tags/memory.md>), [performance](<https://devfeed.tech/tags/performance.md>), [processor](<https://devfeed.tech/tags/processor.md>), [server](<https://devfeed.tech/tags/server.md>), [web](<https://devfeed.tech/tags/web.md>)

### AI overview

This article explains how caching avoids repeatedly recalculating or fetching data, improving performance and reducing costs. It examines cache layers in computer processors and memory, their capacity and latency trade-offs, and the role of storage in Stack Overflow's production architecture.

### Source excerpt

This is #5 in a very long series of posts on Stack Overflow's architecture. Previous post (#4): Stack Overflow: How We Do Monitoring - 2018 Edition So...caching. What is it? It's a way to get a quick payoff by not re-calculating or fetching things over and over, resulting in performance and cost wins. That's even where the name comes from, it's a short form of the "ca-ching!" cash register sound from the dark ages of 2014 when physical currency was still a thing, before Apple Pay. I'm a dad now, deal with it. Let's say we need to call an API or query a database server or just take a bajillion numbers (Google says that's an actual word, I checked) and add them up. Those are all relatively crazy expensive. So we cache the result - we keep it handy for re-use. Why Do We Cache? I think it's important here to discuss just how expensive some of the above things are. There are several layers of caching already in play in your modern computer. As a concrete example, we're going to use one of our web servers which currently houses a pair of Intel Xeon E5-2960 v3 CPUs and 2133MHz DIMMs. Cache access is a "how many cycles" feature of a processor, so by knowing that we always run at 3.06GHz (performance power mode), we can derive the latencies (Intel architecture reference here - these processors are in the Haswell generation): L1 (per core): 4 cycles or ~1.3ns latency - 12x 32KB+32KB L2 (per core): 12 cycles or ~3.92ns latency - 12x 256KB L3 (shared): 34 cycles or ~11.11ns latency - 30MB System memory: ~100ns latency - 8x 8GB Each cache layer is able to store more, but is farther away. It's a trade-off in processor design with balances in play. For example, more memory per core means (almost certainly) on average putting it farther away on the chip from the core and that has costs in latency, opportunity costs, and power consumption. How far an electric charge has to travel has substantial impact at this scale; remember that distance is multiplied by billions every second. And I

## Codename One 3.6 Release Plan

DevFeed: [Codename One 3.6 Release Plan](<https://devfeed.tech/articles/codename-one-3-6-release-plan-19253.md>)

Original publisher: [Read original article](<https://www.codenameone.com/blog/codename-one-3-6-release-plan/>)

Author: Shai Almog

Published: 2017-01-03T00:00:00Z

Content type: release

Language: en

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

Topics: [releases](<https://devfeed.tech/topics/releases.md>), [Software as a service](<https://devfeed.tech/topics/saas.md>), [iOS](<https://devfeed.tech/topics/ios.md>)

Tags: [bugs](<https://devfeed.tech/tags/bugs.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [ios](<https://devfeed.tech/tags/ios.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [product-release](<https://devfeed.tech/tags/product-release.md>), [release](<https://devfeed.tech/tags/release.md>), [releases](<https://devfeed.tech/tags/releases.md>), [saas](<https://devfeed.tech/tags/saas.md>)

### AI overview

Codename One plans to release version 3.6 on January 16, with a code freeze beginning January 9 during which only critical bugs will be fixed with peer review. The release plan shifts from four releases per year to a three-release cycle, while some postponed features are expected to move to the 3.7 cycle.

### Source excerpt

We will release Codename One 3.6 on the 16th of January, this means we will enter code freeze on the 9th during which only critical bugs will be fixed with peer review. Since Codename One is a SaaS product release cycles aren't as crucial for most of us but they provide a framework both for versioned builds and for us to focus on the more mundane aspects of product maintenance.

## Bitsliced SipHash

DevFeed: [Bitsliced SipHash](<https://devfeed.tech/articles/bitsliced-siphash-38922.md>)

Original publisher: [Read original article](<https://idea.popcount.org/2013-01-30-bitsliced-siphash>)

Author: Marek

Published: 2013-01-29T23:00:00Z

Content type: tutorial

Language: en

Sources: [Marek Majkowski](<https://devfeed.tech/sources/marek-majkowski.md>)

Topics: [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [parallel](<https://devfeed.tech/topics/parallel.md>), [implementation](<https://devfeed.tech/topics/implementation.md>), [C](<https://devfeed.tech/topics/c.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [c](<https://devfeed.tech/tags/c.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [matrix](<https://devfeed.tech/tags/matrix.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [simd](<https://devfeed.tech/tags/simd.md>), [speed](<https://devfeed.tech/tags/speed.md>), [sse](<https://devfeed.tech/tags/sse.md>)

### AI overview

This article explains bitslicing through a SipHash implementation. It describes rewriting an algorithm as simple bit-level logical operations applied to wide SIMD vectors, which can reduce repeated parallel computations. It also discusses the substantial cost of transposing input and output bit matrices.

### Source excerpt

Bitsliced SipHash Few days ago I presented a Python and a C implementation of SipHash. This time for no reason whatsoever I implemented a bitsliced version of it. Bitslicing a crypto algorithm is usually done to speed it up when doing massively parallel operations. For example when trying to find a collision with brute force. Bitsliced implementation is only useful if you have a large number of exactly the same mathematical operations to be computed in parallel.

## Single Writer Principle

DevFeed: [Single Writer Principle](<https://devfeed.tech/articles/single-writer-principle-13617.md>)

Original publisher: [Read original article](<https://mechanical-sympathy.blogspot.com/2011/09/single-writer-principle.html>)

Author: Martin Thompson (noreply@blogger.com)

Published: 2011-09-22T14:24:00Z

Content type: tutorial

Language: en

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

Topics: [Scalability](<https://devfeed.tech/topics/scalability.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Operating system](<https://devfeed.tech/topics/operating-system.md>), [Kernel](<https://devfeed.tech/topics/kernel.md>), [cpu](<https://devfeed.tech/topics/cpu.md>)

Tags: [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-control](<https://devfeed.tech/tags/concurrency-control.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [intel](<https://devfeed.tech/tags/intel.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [latency](<https://devfeed.tech/tags/latency.md>), [performance](<https://devfeed.tech/tags/performance.md>), [processor-affinity](<https://devfeed.tech/tags/processor-affinity.md>), [scalability](<https://devfeed.tech/tags/scalability.md>)

### AI overview

The article explains that contention among multiple writers is a major scalability limitation. It compares mutual exclusion, typically implemented with locks, with optimistic concurrency control, describing how contention can increase queuing, latency, and reduce throughput.

### Source excerpt

When trying to build a highly scalable system the single biggest limitation on scalability is having multiple writers contend for any item of data or resource. Sure, algorithms can be bad, but let's assume they have a reasonable Big O notation so we'll focus on the scalability limitations of the systems design. I keep seeing people just accept having multiple writers as the norm. There is a lot of research in computer science for managing this contention that boils down to 2 basic approaches. One is to provide mutual exclusion to the contended resource while the mutation takes place; the other is to take an optimistic strategy and swap in the changes if the underlying resource has not changed while you created the new copy. Mutual Exclusion Mutual exclusion is the means by which only one writer can have access to a protected resource at a time, and is usually implemented with a locking strategy. Locking strategies require an arbitrator, usually the operating system kernel, to get involved when the contention occurs to decide who gains access and in what order. This can be a very expensive process often requiring many more CPU cycles than the actual transaction to be applied to the business logic would use. Those waiting to enter the critical section, in advance of performing the mutation must queue, and this queuing effect (Little's Law) causes latency to become unpredictable and ultimately restricts throughput. Optimistic Concurrency Control Optimistic strategies involve taking a copy of the data, modifying it, then copying back the changes if data has not mutated in the meantime. If a change has happened in the meantime you repeat the process until successful. This repeating of the process increases with contention and therefore causes a queuing effect just like with mutual exclusion. If you work with a source code control system, such as Subversion or CVS, then you are using this algorithm every day. Optimistic strategies can work with data but do not work so wel