# IO

Input/output (I/O) is the use of streams to read data from sources and write data to destinations in computer programs.

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

## CVE-2026-77312 - Flyto2 Core: Arbitrary file write via unguarded data.\*/file.\* modules (incomplete fix of CVE-2026-67429)

DevFeed: [CVE-2026-77312 - Flyto2 Core: Arbitrary file write via unguarded data.\*/file.\* modules (incomplete fix of CVE-2026-67429)](<https://devfeed.tech/articles/cve-2026-77312-flyto2-core-arbitrary-file-write-via-unguarded-data-file-modules-incomplete-fix-of-cve-2026-67429-144622.md>)

Original publisher: [Read original article](<https://cvefeed.io/vuln/detail/CVE-2026-77312>)

Author: CVEFEED.io; github.com

Published: 2026-11-19T22:18:44Z

Content type: news

Language: en

Sources: [Latest High/Critical Vulnerabilitiy Feed](<https://devfeed.tech/sources/latest-high-critical-vulnerabilitiy-feed.md>)

Topics: [cve remediation](<https://devfeed.tech/topics/cve-remediation.md>), [IO](<https://devfeed.tech/topics/io.md>), [file](<https://devfeed.tech/topics/file.md>), [CSV](<https://devfeed.tech/topics/csv.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [absolute](<https://devfeed.tech/tags/absolute.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-workflows](<https://devfeed.tech/tags/agent-workflows.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [automation](<https://devfeed.tech/tags/automation.md>), [boundary](<https://devfeed.tech/tags/boundary.md>), [code](<https://devfeed.tech/tags/code.md>), [code-execution](<https://devfeed.tech/tags/code-execution.md>), [copy](<https://devfeed.tech/tags/copy.md>), [core](<https://devfeed.tech/tags/core.md>), [csv](<https://devfeed.tech/tags/csv.md>), [cve](<https://devfeed.tech/tags/cve.md>), [cve-2026-77312](<https://devfeed.tech/tags/cve-2026-77312.md>), [data](<https://devfeed.tech/tags/data.md>), [execution](<https://devfeed.tech/tags/execution.md>), [file](<https://devfeed.tech/tags/file.md>), [flyto-core](<https://devfeed.tech/tags/flyto-core.md>), [flytohub](<https://devfeed.tech/tags/flytohub.md>), [modules](<https://devfeed.tech/tags/modules.md>), [write](<https://devfeed.tech/tags/write.md>)

### AI overview

Before Flyto2 Core 2.26.8, the fix for CVE-2026-67429 guarded only selected file-writing modules, leaving data.csv.write, data.json_to_csv, file.copy and file.move outside FLYTO_SANDBOX_DIR confinement; the advisory also notes unguarded modules across data.*, file.* and report-writer families. data.csv.write blocks paths containing ".." but does not reject absolute paths, while the other named modules accept caller-controlled paths without the canonical guard. A caller who can execute modules or recipes could write outside the sandbox and potentially overwrite sensitive host files, leading to code execution. The issue is fixed in version 2.26.8.

### Source excerpt

CVE ID :CVE-2026-77312 Published : Nov. 19, 2026, 10:18 p.m. | 2 hours, 53 minutes ago Description :Flyto2 Core is an execution kernel for automation and AI-agent workflows. Prior to 2.26.8, the earlier CVE-2026-67429 remediation applied validate_path_with_env_config() to only a hand-picked set of file-writing modules, leaving data.csv.write in src/core/modules/atomic/data/csv_write.py, data.json_to_csv in src/core/modules/atomic/data/json_to_csv.py, file.copy in src/core/modules/atomic/file/copy.py, and file.move in src/core/modules/atomic/file/move.py outside the FLYTO_SANDBOX_DIR confinement boundary. The advisory also identifies unguarded modules across the broader data.*, file.*, and report-writer families. data.csv.write relies on a .. substring denylist that does not reject absolute paths, while the other named modules accept caller-controlled output or destination paths without the canonical guard. A caller able to execute modules or recipes can therefore write attacker-controlled content outside the configured sandbox, potentially overwriting application code, recipes, startup files, scheduled-task files, or authorization files and gaining code execution on the host. This issue is fixed in version 2.26.8. Severity: 10.0 | CRITICAL Visit the link for more details, such as CVSS details, affected products, timeline, and more...

## Gateway-Free Kafka Streaming from FPGA-Based Detectors: A Bare-Metal Pipelined Producer on Zynq-7000

DevFeed: [Gateway-Free Kafka Streaming from FPGA-Based Detectors: A Bare-Metal Pipelined Producer on Zynq-7000](<https://devfeed.tech/articles/gateway-free-kafka-streaming-from-fpga-based-detectors-a-bare-metal-pipelined-producer-on-zynq-7000-140403.md>)

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

Author: Fernanda Zapata Bascu\\~n\\'an, Mat\\'ias Hampel

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

Content type: article

Language: en

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

Topics: [Xilinx Zynq](<https://devfeed.tech/topics/xilinx-zynq.md>), [Apache Kafka](<https://devfeed.tech/topics/apache-kafka.md>), [Event-Streaming](<https://devfeed.tech/topics/event-streaming.md>), [fpga](<https://devfeed.tech/topics/fpga.md>), [lwIP](<https://devfeed.tech/topics/lwip.md>), [IO](<https://devfeed.tech/topics/io.md>)

Tags: [bare-metal](<https://devfeed.tech/tags/bare-metal.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [cs-ni](<https://devfeed.tech/tags/cs-ni.md>), [dma](<https://devfeed.tech/tags/dma.md>), [errors](<https://devfeed.tech/tags/errors.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [fpga](<https://devfeed.tech/tags/fpga.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [lwip](<https://devfeed.tech/tags/lwip.md>), [measurement](<https://devfeed.tech/tags/measurement.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [streaming](<https://devfeed.tech/tags/streaming.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [topic](<https://devfeed.tech/tags/topic.md>)

### AI overview

A bare-metal Kafka producer on a Zynq-7000 streams detector events directly from programmable logic to a standard broker, without an intermediate gateway. Events move over AXI4-Stream and AXI DMA to the processing system, which builds ProduceRequest messages and sends them through lwIP's raw TCP/IP API. A configurable limit on outstanding requests was tested at pipeline depths 1, 2, 4, and 8 using two DMA sources across 80 runs totaling 400,000 events. Mean throughput rose from about 5.3 kevents/s at depth 1 to 16.2 kevents/s at depth 4 and 16.8-17.5 kevents/s at depth 8. Median publish-to-acknowledgement time was lowest at depth 4 (0.66 ms), versus 0.83-0.86 ms at depth 8; depth 4's P95 was 0.81-0.83 ms. All runs had the expected frame sequence in exported metrics and no recorded Kafka errors. The excerpt reports these measurements but does not establish performance beyond the tested setup.

### Source excerpt

arXiv:2611.22674v1 Announce Type: new Abstract: We present a bare-metal Apache Kafka producer implemented on a Zynq-7000 System-on-Chip (SoC) for event-driven data acquisition. Events are generated in Programmable Logic (PL), transferred to the Processing System (PS) through AXI4-Stream and AXI DMA, and published to a standard Kafka broker without an intermediate gateway computer. The PS constructs ProduceRequest messages and transmits them through the lwIP raw TCP/IP API. A configurable pipeline limits the number of outstanding Kafka requests. Pipeline depths of D = 1, 2, 4, and 8 were evaluated with two independent DMA sources. For each depth, 20 independent runs of 5,000 events were acquired, for 400,000 event records in total. Each event carries a 32-bit frame counter and a 32-bit PL timestamp. PS-side instrumentation records DMA start and completion, publication, successful local tcp_write() acceptance, and reception of the corresponding Kafka acknowledgement. Measurement records are exported to a separate Kafka topic after the timed event stream has completed. Each of the 80 runs contained 5,000 records with frame values from 0 to 4,999, with no sequence discontinuities in the exported metric records and no recorded Kafka errors. Mean operational throughput was approximately 5.3 kevents/s at D = 1, 9.4-9.6 kevents/s at D = 2, 16.2 kevents/s at D = 4, and 16.8-17.5 kevents/s at D = 8. The median publish-to-acknowledgement interval was 1.62-1.64 ms at D = 1, 0.98 ms at D = 2, 0.66 ms at D = 4, and 0.83-0.86 ms at D = 8. At D = 4, the corresponding P95 values were 0.81-0.83 ms.

## What Production AI Demands from the Data Layer

DevFeed: [What Production AI Demands from the Data Layer](<https://devfeed.tech/articles/what-production-ai-demands-from-the-data-layer-139722.md>)

Original publisher: [Read original article](<https://blog.everpuredata.com/solutions/what-production-ai-demands-from-the-data-layer/>)

Author: Sabrinath Rao

Published: 2026-11-17T13:50:00Z

Content type: opinion

Language: en

Sources: [Everpure](<https://devfeed.tech/sources/everpure.md>)

Topics: [AI Infrastructure](<https://devfeed.tech/topics/ai-infrastructure.md>), [AI Architecture](<https://devfeed.tech/topics/ai-architecture.md>), [scalable-architecture](<https://devfeed.tech/topics/scalable-architecture.md>), [AI Factory](<https://devfeed.tech/topics/ai-factory.md>), [AI Context Management](<https://devfeed.tech/topics/ai-context-management.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [IO](<https://devfeed.tech/topics/io.md>)

Tags: [accelerators](<https://devfeed.tech/tags/accelerators.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-and-machine-learning](<https://devfeed.tech/tags/ai-and-machine-learning.md>), [ai-data](<https://devfeed.tech/tags/ai-data.md>), [ai-data-layer](<https://devfeed.tech/tags/ai-data-layer.md>), [ai-training](<https://devfeed.tech/tags/ai-training.md>), [ai-training-and-inference](<https://devfeed.tech/tags/ai-training-and-inference.md>), [ai-workloads](<https://devfeed.tech/tags/ai-workloads.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [attention](<https://devfeed.tech/tags/attention.md>), [bandwidth](<https://devfeed.tech/tags/bandwidth.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [bottleneck](<https://devfeed.tech/tags/bottleneck.md>), [cache](<https://devfeed.tech/tags/cache.md>), [data](<https://devfeed.tech/tags/data.md>), [data-layer](<https://devfeed.tech/tags/data-layer.md>), [flashblade-exa](<https://devfeed.tech/tags/flashblade-exa.md>), [flashblade-object-storage](<https://devfeed.tech/tags/flashblade-object-storage.md>), [gpus](<https://devfeed.tech/tags/gpus.md>), [inference](<https://devfeed.tech/tags/inference.md>), [production-ai](<https://devfeed.tech/tags/production-ai.md>), [solutions](<https://devfeed.tech/tags/solutions.md>)

### AI overview

The post argues that production AI benefits when storage resources scale independently and are measured by their effect on useful compute. FlashBlade//EXA separates metadata operations from payload traffic, allowing each path to scale on demand; STN reports growth from about 35 GB/s to as much as 100 GB/s. In submitted MLPerf Storage v3.0 results, it ranked first on the reported checkpointing and KV cache metrics, with checkpoint write bandwidth rising from 327.65 GiB/s on 10 data nodes to 877.52 GiB/s on 30; the author cautions these workloads are proxies and recommends testing real workload mixes. Purity//FB 4.8.4 adds S3 over RDMA through standard S3 calls, though the newer capability has early-release constraints. Pure KVA retains attention states and integrates with vLLM; company benchmarks report faster inference and improved time to first token. For multi-tenancy, file systems are assigned to separate data node groups to isolate drives, ports, and failures. The suggested evaluations include checkpoint stall time, goodput, concurrent time to first token, data copies, node-failure impact, and watts per sustained GB/s.

### Source excerpt

What Production AI Demands from the Data Layer by Everpure Blog Explore how a scalable AI data layer can accelerate checkpointing and inference while helping keep GPUs productive across AI workloads. The post What Production AI Demands from the Data Layer appeared first on Everpure Blog.

## CodeSOD: Building a Line

DevFeed: [CodeSOD: Building a Line](<https://devfeed.tech/articles/codesod-building-a-line-139424.md>)

Original publisher: [Read original article](<https://thedailywtf.com/articles/building-a-line>)

Author: Remy Porter

Published: 2026-11-17T06:30:00Z

Content type: article

Language: en

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

Topics: [concatenation](<https://devfeed.tech/topics/concatenation.md>), [IO](<https://devfeed.tech/topics/io.md>)

Tags: [abstraction](<https://devfeed.tech/tags/abstraction.md>), [builder](<https://devfeed.tech/tags/builder.md>), [codesod](<https://devfeed.tech/tags/codesod.md>), [concatenation](<https://devfeed.tech/tags/concatenation.md>), [file](<https://devfeed.tech/tags/file.md>), [function](<https://devfeed.tech/tags/function.md>), [performance](<https://devfeed.tech/tags/performance.md>), [return](<https://devfeed.tech/tags/return.md>), [string](<https://devfeed.tech/tags/string.md>)

### AI overview

The function reads a file in full, adds a line feed to the resulting string, appends that single combined value to a StringBuilder, and returns it. The author calls this a superstitious use of StringBuilder: for the current task, returning the read contents plus a line feed is simpler. Separate StringBuilder appends could make sense if the output were expected to grow or change, but the author considers that setup premature abstraction here.

### Source excerpt

There's an unofficial category of posts here that I call "Somebody told us string builders were more efficient, so we always use string builders, regardless of whether or not that actually makes sense," or STUSBWMESWAUSBROWONTAMS, for short. Probably should workshop that name some. In any case, Adam sends us a new entry for that collection: Public Function ReadFromFile(ByVal filename As String) As String Dim sb As StringBuilder = New StringBuilder() Dim str As String = String.Empty Using sr As StreamReader = File.OpenText(filename) str = sr.ReadToEnd() sb.Append(str & Constants.vbLf) End Using Return sb.ToString() End Function This function takes a filename, opens a file, reads the entire contents of the file to a variable. It concatenates a line feed to the end of the string it just read, then appends all of that to a string builder. Finally, we return sb.ToString(), taking the single string in the string builder, appending nothing to it, and returning the result. I'd almost, almost forgive the code if it was more like: str = sr.ReadToEnd() sb.Append(str) sb.Append(Constants.vbLf) You're not actually gaining much from this, but it follows the broad pattern of "use a string builder" so that if you ever wanted to change the structure of the output, you're already set up to prepend/append new text in a scalable way. I'd argue that's premature abstraction, though: a simple return sr.ReadToEnd() & Constants.vbLf would do the current job. The code that we have is a clear superstitious use of string builders. The string builder is used as a charm against poor performance, without understanding why one might use it, or how it might work; string concatenation means string builder, always and forever, "why" doesn't enter into it. [Advertisement] Keep all your packages and Docker containers in one place, scan for vulnerabilities, and control who can access different feeds. ProGet installs in minutes and has a powerful free version with a lot of great features that you can upg

## pg\_fastload 1.0.0 released: parallel bulk loading for PostgreSQL

DevFeed: [pg\_fastload 1.0.0 released: parallel bulk loading for PostgreSQL](<https://devfeed.tech/articles/pg-fastload-1-0-0-released-parallel-bulk-loading-for-postgresql-137837.md>)

Original publisher: [Read original article](<https://www.postgresql.org/about/news/pg_fastload-100-released-parallel-bulk-loading-for-postgresql-3445/>)

Author: Pg Fastload

Published: 2026-11-17T00:00:00Z

Content type: release

Language: en

Sources: [PostgreSQL news](<https://devfeed.tech/sources/postgresql-news.md>)

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [CSV](<https://devfeed.tech/topics/csv.md>), [IO](<https://devfeed.tech/topics/io.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [background](<https://devfeed.tech/tags/background.md>), [cache](<https://devfeed.tech/tags/cache.md>), [column](<https://devfeed.tech/tags/column.md>), [copy](<https://devfeed.tech/tags/copy.md>), [core](<https://devfeed.tech/tags/core.md>), [csv](<https://devfeed.tech/tags/csv.md>), [data](<https://devfeed.tech/tags/data.md>), [encoding](<https://devfeed.tech/tags/encoding.md>), [export](<https://devfeed.tech/tags/export.md>), [faster](<https://devfeed.tech/tags/faster.md>), [fields](<https://devfeed.tech/tags/fields.md>), [file](<https://devfeed.tech/tags/file.md>), [filter](<https://devfeed.tech/tags/filter.md>), [fork](<https://devfeed.tech/tags/fork.md>), [format](<https://devfeed.tech/tags/format.md>), [function](<https://devfeed.tech/tags/function.md>), [loading](<https://devfeed.tech/tags/loading.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>)

### AI overview

pg_fastload 1.0.0 parallelizes reading, parsing, and tuple formation across background workers while the issuing backend serially inserts rows, keeping the load in one transaction. A single reader scans the file once and sends chunks to parser workers, so total input read remains one file size. It is a source-level fork of pg_bulkload 3.1.23 and preserves its control-file syntax, TYPE values, log format, and WRITER modes. The parallel path falls back automatically, with an INFO message, for unsupported conditions including FILTER, explicit ENCODING, constraints, PARSE_ERRORS tolerance, STDIN, and TUPLE or FUNCTION input. In the cited 1 GiB CSV test, default 15-worker pg_fastload took 1.37 seconds versus 5.81 seconds serial pg_fastload, 6.98 seconds for upstream pg_bulkload's fastest mode, and 8.32 seconds for COPY FROM. Results depend on the reported workload and hardware; the excerpt also describes progress reporting, snapshot-auditable exports, and optional index dropping during loads.

### Source excerpt

pg_fastload 1.0.0 is a parallel bulk loader for PostgreSQL, 1.58x faster than the best pg_bulkload mode and 6.07x faster than COPY. It parallelises the loading pipeline across background workers while keeping the load inside a single transaction. It is a source-level fork of pg_bulkload 3.1.23, so control-file syntax, TYPE values, log format and WRITER modes are unchanged. Repository: github.com/yuansong/pg_fastload Release: pg_fastload v1.0.0 License: BSD 3-Clause, with the upstream pg_bulkload copyright notices retained The problem pg_bulkload and COPY both run the whole load in one backend: read, parse, form the tuple, write. On a 16-core machine that leaves 15 cores idle, and the parse step is usually the expensive one. For CSV it is a byte-at-a-time state machine followed by a type input function per column. How it works The load has four stages: read input, parse record and split fields, form the tuple, and insert. Stages 1-3 move to background workers; stage 4 stays serial in the backend that issued the load: one reader worker -> N parser workers -> leader writes Design points that matter in practice: The input file is read exactly once. A single reader scans sequentially and hands chunks to the workers over shm_mq; the workers never open the file. Total read volume stays at 1x the file size, so the speedup does not invert once the data is larger than the page cache. It is still one transaction. No second connection, no early visibility of uncommitted rows, and a bad row aborts the whole load rather than leaving a worker-timing-dependent subset behind. 13 conditions the parallel path cannot honour fall back automatically, with one INFO line saying why: FILTER and FORCE_NOT_NULL, explicit ENCODING, NOT NULL or CHECK constraints, PARSE_ERRORS tolerance, STDIN input, TUPLE and FUNCTION input, and others. The serial path itself was optimised. Records without quotes or CRs take a memchr bulk split instead of the byte-at-a-time loop. Progress reporting and export E

## Seagate is bringing back the hybrid drive, but you have to supply the SSD

DevFeed: [Seagate is bringing back the hybrid drive, but you have to supply the SSD](<https://devfeed.tech/articles/seagate-is-bringing-back-the-hybrid-drive-but-you-have-to-supply-the-ssd-129545.md>)

Original publisher: [Read original article](<https://www.techspot.com/news/114522-seagate-bringing-back-hybrid-drive-but-you-have.html>)

Author: Alfonso Maruccia

Published: 2026-11-11T22:18:00Z

Content type: news

Language: en

Sources: [TechSpot](<https://devfeed.tech/sources/techspot.md>)

Topics: [Cache](<https://devfeed.tech/topics/cache.md>), [M.2 NVMe](<https://devfeed.tech/topics/m-2-nvme.md>), [IO](<https://devfeed.tech/topics/io.md>), [NVMe](<https://devfeed.tech/topics/nvme.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-data-centers](<https://devfeed.tech/tags/ai-data-centers.md>), [cache](<https://devfeed.tech/tags/cache.md>), [caching](<https://devfeed.tech/tags/caching.md>), [external-storage](<https://devfeed.tech/tags/external-storage.md>), [fpga](<https://devfeed.tech/tags/fpga.md>), [gaming](<https://devfeed.tech/tags/gaming.md>), [hard-drive](<https://devfeed.tech/tags/hard-drive.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [hdd](<https://devfeed.tech/tags/hdd.md>), [hybrid](<https://devfeed.tech/tags/hybrid.md>), [hybrid-storage](<https://devfeed.tech/tags/hybrid-storage.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [linux](<https://devfeed.tech/tags/linux.md>), [m-2](<https://devfeed.tech/tags/m-2.md>), [macos](<https://devfeed.tech/tags/macos.md>), [os](<https://devfeed.tech/tags/os.md>), [seagate](<https://devfeed.tech/tags/seagate.md>), [ssd](<https://devfeed.tech/tags/ssd.md>), [storage](<https://devfeed.tech/tags/storage.md>)

### AI overview

FireCuda Forge pairs an 8TB or 20TB external HDD with a user-supplied M.2 SSD, using Seagate's Alkemi system to move frequently accessed data into a cache. Alkemi runs on an FPGA and embedded Linux, monitors file access, and is reported to have achieved a 90% cache hit rate across gaming sessions totaling 4.3 million I/O requests. Seagate claims up to 2,500MB/s read and 2,000MB/s write over USB4 when the cache is populated. The SSD is not included, the usable cache is capped at 1TB, and compatible drives must be M.2 2280, PCIe Gen3 or newer. The device appears as a single drive to the operating system, simplifying management but creating a potential reliability risk if either storage component fails. Listed prices are $699 for 8TB and $899 for 20TB; official OS support is Windows 11 and macOS 26.

### Source excerpt

Seagate has introduced the FireCuda Forge, an external "desktop" HDD designed to approach NVMe-class data rates by embedding a smaller SSD in the same enclosure. Just like classic hybrid drives, FireCuda Forge can store frequently used data on a much faster solid-state cache. Unlike those older designs, however, the SSD... Read Entire Article

## Placing LLM Lookup Tables by Per-Layer Prefetch Deadlines

DevFeed: [Placing LLM Lookup Tables by Per-Layer Prefetch Deadlines](<https://devfeed.tech/articles/placing-llm-lookup-tables-by-per-layer-prefetch-deadlines-127806.md>)

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

Author: Wen Huang, Jack Liu

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

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Cache](<https://devfeed.tech/topics/cache.md>), [NVMe](<https://devfeed.tech/topics/nvme.md>), [rdma](<https://devfeed.tech/topics/rdma.md>), [IO](<https://devfeed.tech/topics/io.md>), [jetstream](<https://devfeed.tech/topics/jetstream.md>)

Tags: [1-4](<https://devfeed.tech/tags/1-4.md>), [agent](<https://devfeed.tech/tags/agent.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cuda](<https://devfeed.tech/tags/cuda.md>), [decode](<https://devfeed.tech/tags/decode.md>), [deepseek](<https://devfeed.tech/tags/deepseek.md>), [device](<https://devfeed.tech/tags/device.md>), [dram](<https://devfeed.tech/tags/dram.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [graph](<https://devfeed.tech/tags/graph.md>), [host-memory](<https://devfeed.tech/tags/host-memory.md>), [kv-cache](<https://devfeed.tech/tags/kv-cache.md>), [layer](<https://devfeed.tech/tags/layer.md>), [layers](<https://devfeed.tech/tags/layers.md>), [llm](<https://devfeed.tech/tags/llm.md>), [lookup](<https://devfeed.tech/tags/lookup.md>), [median](<https://devfeed.tech/tags/median.md>), [memory](<https://devfeed.tech/tags/memory.md>), [model](<https://devfeed.tech/tags/model.md>), [tables](<https://devfeed.tech/tags/tables.md>)

### AI overview

SlackTier places Engram lookup tables according to each layer's prefetch deadline, session reuse, and shared-device contention. In SGLang it starts lookups at step start, prioritizes the short-window layer, and divides a small GPU row cache across layers; the decode CUDA-graph path is bit-exact with the original gather. Layer 14 can use uncached NVMe without measurable decode cost. Putting both tables on four NVMe disks raises mean time per output token by at most 1.4% on agent and chat replays while reducing host memory from 212 to 34 GiB. With RDMA from another node's memory, both tables need no cache and one copy serves two instances. In a KV-constrained agent workload, using the freed memory for host KV cache at the same budget increased median throughput 36% and reduced median p90 time to first token from 38 to 24 seconds. The abstract notes that static hot sets transfer poorly for agent and chat traffic, which reuses rows within sessions.

### Source excerpt

arXiv:2611.13413v1 Announce Type: new Abstract: DeepSeek-V4.1's 203 GB of Engram n-gram tables sit in host DRAM today, taking 190 of the 223 GiB a 4-GPU serving process uses. Row indices depend only on input tokens, so reads can start with each step and overlap earlier layers. V4.1's two Engram layers have windows that differ by 30x (0.3 vs. 9.3 ms). We show that this deadline, together with session reuse and contention on a shared device, decides which tier each table can use and which layers need cache, and we give a model that predicts the resulting slowdown from measured read times. Agent and chat traffic reuse rows within sessions, and static hot sets transfer poorly. We build SlackTier, a table tier for SGLang that issues all lookups at step start. It reads the short-window layer first and splits a small GPU row cache across layers. The path runs inside the decode CUDA graph and is bit-exact with the original gather. Layer 14's table can go to NVMe uncached with no measurable decode cost. With both tables on four NVMe disks, mean time per output token on agent and chat replays rises at most 1.4% over unmodified SGLang, and host memory falls from 212 to 34 GiB. Both tables need no cache when read over RDMA (remote direct memory access) from another node's memory; one copy serves two instances. On a KV-constrained agent workload, using the freed memory as host KV cache at the same memory budget raises median throughput by 36% and cuts median p90 time to first token from 38 to 24 s.

## Monads in Lean

DevFeed: [Monads in Lean](<https://devfeed.tech/articles/monads-in-lean-129771.md>)

Original publisher: [Read original article](<https://eli.thegreenplace.net/2026/monads-in-lean/>)

Author: Eli Bendersky

Published: 2026-11-11T03:25:00Z

Content type: article

Language: en

Sources: [Eli Bendersky](<https://devfeed.tech/sources/eli-bendersky.md>)

Topics: [Lean](<https://devfeed.tech/topics/lean.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [IO](<https://devfeed.tech/topics/io.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [OCaml](<https://devfeed.tech/topics/ocaml.md>)

Tags: [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [haskell](<https://devfeed.tech/tags/haskell.md>), [lean](<https://devfeed.tech/tags/lean.md>), [lean-4](<https://devfeed.tech/tags/lean-4.md>), [misc](<https://devfeed.tech/tags/misc.md>)

### AI overview

The post builds up Lean 4 monads through a sequence of expression evaluators. It starts with `Option` for propagating division-by-zero failure, then replaces nested matching with `bind` (`>>=`) and `do` notation. A generic evaluator works with either `Option` or `Except`. Further examples combine failure with logging in `LoggedOption`, carry variable assignments through a stateful evaluator, and use `OptionT IO` to combine failure with printing. The post explains `bind` as sequencing computations while encapsulating effects, and describes the left identity, right identity, and associativity laws; Lean's `LawfulMonad` class requires proofs of those laws, while `Monad` alone does not.

### Source excerpt

This post demonstrates how to use monads in the Lean programming language (Lean 4, to be specific). If you're not familiar with Lean, this part of the language is very similar to other functional programming languages, like Haskell or OCaml. Motivating example - evaluating expressions Suppose we want to write a ...

## Comparing Write, Read, and Query Performance of General-Purpose and Columnar Data Serialization Formats at Increasing Scale: An Empirical Benchmark Study with Statistical Validation on Synthetic and Real-World Data

DevFeed: [Comparing Write, Read, and Query Performance of General-Purpose and Columnar Data Serialization Formats at Increasing Scale: An Empirical Benchmark Study with Statistical Validation on Synthetic and Real-World Data](<https://devfeed.tech/articles/comparing-write-read-and-query-performance-of-general-purpose-and-columnar-data-serialization-formats-at-increasing-scale-an-empirical-benchmark-study-with-statistical-va-125664.md>)

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

Author: Asra Fathima

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

Content type: article

Language: en

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

Topics: [Data serialization](<https://devfeed.tech/topics/data-serialization.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [parquet](<https://devfeed.tech/topics/parquet.md>), [Serialization protocols](<https://devfeed.tech/topics/serialization-protocols.md>), [IO](<https://devfeed.tech/topics/io.md>)

Tags: [benchmark](<https://devfeed.tech/tags/benchmark.md>), [columnar](<https://devfeed.tech/tags/columnar.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [cs-pf](<https://devfeed.tech/tags/cs-pf.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [data-serialization](<https://devfeed.tech/tags/data-serialization.md>), [performance](<https://devfeed.tech/tags/performance.md>), [query](<https://devfeed.tech/tags/query.md>), [scale](<https://devfeed.tech/tags/scale.md>)

### AI overview

Across four dataset scales and two different hosts, the benchmark found that selective queries requiring full deserialization were one to three orders of magnitude more expensive than approaches that avoid it. Indexed SQLite was significantly fastest for selective access at every scale; Parquet's pyarrow pushdown was significantly cheaper than naive materialization. Pickle was significantly faster to write than Parquet on both hosts, a result supported by 20 trials rather than the earlier five-trial pilot. A 1.47-million-row public fraud dataset reproduced the query-performance gap and indexed SQLite advantage. The study compared write time, storage size, read time, and query time, using statistical tests to assess differences.

### Source excerpt

arXiv:2611.10398v1 Announce Type: new Abstract: This study presents an empirical benchmark comparing nine format and access-method combinations across six data serialization technologies: CSV (including a column-projected variant), gzip CSV, JSON Lines, Python Pickle, SQLite (unindexed and indexed), and Apache Parquet (naive and pyarrow pushdown). A synthetic dataset was generated at four scales (50,000 to 3,000,000 rows), with write time, storage size, read time, and query time measured across twenty trials on two independent hosts, a native 24 GB Apple Silicon machine and a memory-constrained, single-core 4 GB Linux virtual machine. Mean, standard deviation, and 95 percent confidence intervals are reported for each host. The most robust finding, stable across every scale and both hosts, is that flat formats requiring full deserialization before filtering are one to three orders of magnitude more expensive for selective queries than any approach that avoids it. Welch t-tests, corroborated by Mann-Whitney U tests, show SQLite (indexed) is significantly fastest for selective access at every scale on both hosts, with the pushdown path of Parquet significantly cheaper than naive materialization. With the increased trial count, the write-time variance of Pickle narrowed enough to show it is significantly faster than Parquet at write time on both hosts, not the statistical tie an earlier five-trial pilot suggested. These findings were confirmed on a real, public 1.47-million-row e-commerce fraud dataset, which reproduced the same order-of-magnitude gap between flat and non-flat formats and the same SQLite (indexed) advantage. These results offer statistically grounded guidance for format selection in data engineering pipelines.

## Fast and Actionable Classification of HPC I/O Time Series

DevFeed: [Fast and Actionable Classification of HPC I/O Time Series](<https://devfeed.tech/articles/fast-and-actionable-classification-of-hpc-i-o-time-series-123698.md>)

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

Author: Maxime Gonthier (RIKEN CCS), Luan Teylo (RIKEN CCS), Francesco Antici (RIKEN CCS), Mihail Popov (LaBRI, UB), Francieli Boito (LaBRI, UB)

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

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [Time Series](<https://devfeed.tech/topics/time-series.md>), [IO](<https://devfeed.tech/topics/io.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [classification](<https://devfeed.tech/tags/classification.md>), [clustering](<https://devfeed.tech/tags/clustering.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [hpc](<https://devfeed.tech/tags/hpc.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>), [temporal](<https://devfeed.tech/tags/temporal.md>), [time-series](<https://devfeed.tech/tags/time-series.md>), [traces](<https://devfeed.tech/tags/traces.md>)

### AI overview

SAGE characterizes jobs' temporal I/O behavior by splitting traces into short windows, learning an alphabet, and representing each trace as a symbol sequence ("genome") for clustering. Evaluated on 819,771 real traces from two HPC systems, its two-stage variant SAGE-2 reduced median intra-cluster metrics by an average of 9.1% versus the best available baseline, K-shape, while clustering in 2 minutes instead of 3.8 hours (109x faster). The authors also report that scheduling with cluster centroids reduced I/O stretch by up to 24% compared with round-robin placement. These are abstract-level reported results; no further evaluation details are provided in the supplied text.

### Source excerpt

arXiv:2611.09646v1 Announce Type: new Abstract: Input/output (I/O) is a major bottleneck for highperformance computing (HPC) performance. One of the challenges is the contention between jobs when sharing the parallel file system. However, tackling this issue depends on knowing the temporal behavior of jobs. In this paper, we propose a clusteringbased approach to characterize jobs' temporal I/O behavior. We propose SAGE, a lightweight method that cuts I/O traces into short windows and learns an alphabet from them. The trace then becomes a sequence of symbols, which we call ''genome'', and we use clustering to separate them into classes. We evaluate SAGE and its two-stage variant SAGE-2 on 819,771 real traces from 2 HPC systems. We compare them against other techniques from the state of the art on three metrics, including one we propose. Compared to K-shape, the best baseline available, SAGE-2 lowers the median intra-cluster metrics by 9.1% on average, and achieves this in 2 minutes of clustering time versus 3.8 hours, a 109x speedup. More importantly, clusters created by SAGE and SAGE-2 carry enough information to act on: we evaluate the use of the cluster centroids for I/O scheduling, and show that our approach can decrease I/O stretch by up to 24% compared to the state of the art (round-robin placement).

## Read, don't copy: replacing file feeds with OpenSharing - Part 2 (How to Implement)

DevFeed: [Read, don't copy: replacing file feeds with OpenSharing - Part 2 (How to Implement)](<https://devfeed.tech/articles/read-don-t-copy-replacing-file-feeds-with-opensharing-part-2-how-to-implement-121796.md>)

Original publisher: [Read original article](<https://www.databricks.com/blog/read-dont-copy-replacing-file-feeds-opensharing-part-2-how-implement>)

Author: Jordan Soldo; Nikhil Tallam

Published: 2026-11-06T22:13:00Z

Content type: tutorial

Language: en

Sources: [Databricks](<https://devfeed.tech/sources/databricks.md>)

Topics: [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [deltalake](<https://devfeed.tech/topics/deltalake.md>), [IO](<https://devfeed.tech/topics/io.md>), [copy](<https://devfeed.tech/topics/copy.md>), [CRUD](<https://devfeed.tech/topics/crud.md>), [CSV](<https://devfeed.tech/topics/csv.md>)

Tags: [access-control](<https://devfeed.tech/tags/access-control.md>), [added](<https://devfeed.tech/tags/added.md>), [admin](<https://devfeed.tech/tags/admin.md>), [all](<https://devfeed.tech/tags/all.md>), [also](<https://devfeed.tech/tags/also.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [api](<https://devfeed.tech/tags/api.md>), [architectures](<https://devfeed.tech/tags/architectures.md>), [automatic](<https://devfeed.tech/tags/automatic.md>), [better](<https://devfeed.tech/tags/better.md>), [bi](<https://devfeed.tech/tags/bi.md>), [bi-tools](<https://devfeed.tech/tags/bi-tools.md>), [blog](<https://devfeed.tech/tags/blog.md>), [copy](<https://devfeed.tech/tags/copy.md>), [data](<https://devfeed.tech/tags/data.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [file](<https://devfeed.tech/tags/file.md>), [implement](<https://devfeed.tech/tags/implement.md>), [pattern](<https://devfeed.tech/tags/pattern.md>), [sharing](<https://devfeed.tech/tags/sharing.md>), [tutorials](<https://devfeed.tech/tags/tutorials.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

For Databricks-to-Databricks sharing, publish a Delta table with history in a share; the recipient mounts it as a catalog and reads it incrementally with Structured Streaming. A checkpoint lets scheduled Trigger.AvailableNow runs process only changes since the previous run, and a table update trigger can run jobs when new data is committed. Durable checkpoint storage is recommended. History is required for incremental reads; Change Data Feed is optional for the basic append-oriented path but needed for the described upserts-and-deletes path. The excerpt cautions that ignoreChanges may re-emit rows and does not propagate deletes. CREATE SHARE and CREATE RECIPIENT require metastore-level privilege. Other recipients use a credentials file; OSS Spark can use the streaming connector, while non-Spark readers pull changes by version range. The excerpt proposes validating a minimal flow with an initial snapshot and subsequent insert, update, and delete.

### Source excerpt

Many data-sharing architectures begin with a familiar pattern: A provider exports...

## Backup from Storage Snapshots: How it works and when to use it

DevFeed: [Backup from Storage Snapshots: How it works and when to use it](<https://devfeed.tech/articles/backup-from-storage-snapshots-how-it-works-and-when-to-use-it-119300.md>)

Original publisher: [Read original article](<https://www.veeam.com/blog/backup-from-storage-snapshots.html>)

Author: Dylan Sams

Published: 2026-11-05T09:42:36Z

Content type: article

Language: en

Sources: [Veeam Software Official Blog](<https://devfeed.tech/sources/veeam-software-official-blog.md>)

Topics: [Data Recovery](<https://devfeed.tech/topics/data-recovery.md>), [save](<https://devfeed.tech/topics/save.md>), [IO](<https://devfeed.tech/topics/io.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [added](<https://devfeed.tech/tags/added.md>), [all](<https://devfeed.tech/tags/all.md>), [appliances](<https://devfeed.tech/tags/appliances.md>), [application](<https://devfeed.tech/tags/application.md>), [backup](<https://devfeed.tech/tags/backup.md>), [backup-recovery](<https://devfeed.tech/tags/backup-recovery.md>), [business](<https://devfeed.tech/tags/business.md>), [data-protection](<https://devfeed.tech/tags/data-protection.md>), [feature](<https://devfeed.tech/tags/feature.md>), [first](<https://devfeed.tech/tags/first.md>), [production](<https://devfeed.tech/tags/production.md>), [reduce](<https://devfeed.tech/tags/reduce.md>), [snapshot](<https://devfeed.tech/tags/snapshot.md>), [snapshots](<https://devfeed.tech/tags/snapshots.md>), [storage](<https://devfeed.tech/tags/storage.md>), [this](<https://devfeed.tech/tags/this.md>), [understand](<https://devfeed.tech/tags/understand.md>), [veeam](<https://devfeed.tech/tags/veeam.md>), [veeam-backup-replication](<https://devfeed.tech/tags/veeam-backup-replication.md>), [vmware](<https://devfeed.tech/tags/vmware.md>), [works](<https://devfeed.tech/tags/works.md>)

### AI overview

Veeam Backup from Storage Snapshots shortens the VMware snapshot window: Veeam creates a VMware snapshot, triggers a snapshot on the array, removes the VMware snapshot, then has a proxy read changed or required data from the array snapshot into a separate backup repository. This limits delta growth and consolidation work, though array and production workloads may still share resources. It requires a supported array and firmware, suitable storage credentials and capacity, and proxy access through a supported transport mode; verify the job session confirms the feature was used. Compatibility and behavior vary by integration, and some disk or storage configurations are excluded. The integration supports VMware vSphere only, not Hyper-V or file shares. A primary array snapshot remains in the production system's failure domain, so it does not replace an independent backup copy.

### Source excerpt

If you have ever watched a production workload struggle while a VMware snapshot was being removed, you already understand the problem this feature is designed to reduce. The post Backup from Storage Snapshots: How it works and when to use it appeared first on Veeam Software Official Blog.

## We can do better than line-buffered output

DevFeed: [We can do better than line-buffered output](<https://devfeed.tech/articles/we-can-do-better-than-line-buffered-output-119307.md>)

Original publisher: [Read original article](<https://nullprogram.com/blog/2026/11/05/>)

Published: 2026-11-05T00:25:25Z

Content type: article

Language: en

Sources: [Chris Wellons](<https://devfeed.tech/sources/chris-wellons.md>)

Topics: [IO](<https://devfeed.tech/topics/io.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [Terminal](<https://devfeed.tech/topics/terminal.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [applications](<https://devfeed.tech/tags/applications.md>), [archive](<https://devfeed.tech/tags/archive.md>), [automatically](<https://devfeed.tech/tags/automatically.md>), [avoid](<https://devfeed.tech/tags/avoid.md>), [better](<https://devfeed.tech/tags/better.md>), [buffer](<https://devfeed.tech/tags/buffer.md>), [but](<https://devfeed.tech/tags/but.md>), [c](<https://devfeed.tech/tags/c.md>), [can](<https://devfeed.tech/tags/can.md>), [comes](<https://devfeed.tech/tags/comes.md>), [consider](<https://devfeed.tech/tags/consider.md>), [cpython](<https://devfeed.tech/tags/cpython.md>), [doesn-t](<https://devfeed.tech/tags/doesn-t.md>), [don-t](<https://devfeed.tech/tags/don-t.md>), [event](<https://devfeed.tech/tags/event.md>), [example](<https://devfeed.tech/tags/example.md>), [experience](<https://devfeed.tech/tags/experience.md>), [faster](<https://devfeed.tech/tags/faster.md>), [file](<https://devfeed.tech/tags/file.md>)

### AI overview

Terminal line buffering can slow noninteractive programs by flushing on each newline. In the author's `tugz` unzip, output stays visible without that per-line cost: the buffer is checked during short stints of work and flushed only after it has been idle for a brief deadline (suggested around 100 ms), allowing several filenames to be written together. This avoids extra writes without a thread and leaves the user interface unchanged. The excerpt contrasts this with glibc's newline-by-newline writes and CPython's flush when buffered output contains a newline, which can emit partial lines.

### Source excerpt

Buffered output typically comes in two flavors: fully buffered and line buffered. If output goes to a terminal then the implementation automatically selects line buffering, flushing its buffer when a line is completed so that it reaches the user immediately. Otherwise it fully buffers, holding output until the buffer is full or an explicit flush event at some arbitrary point in the future. Line buffering is a common bottleneck in non-interactive terminal applications such that it's worth redirecting output to a file or pipe in order to avoid it. It doesn't have to be this way. We can have our cake and eat it, too: promptly delivering lines to a terminal at fully-buffered speeds. For example, Info-ZIP unzip prints file names as it extract them from an archive. This printout dominates extraction time of archives with many small files. Sometimes I run unzip without options, then my terminal floods with file names and I know that my extraction is bottlenecked. So I cancel and restart with -q (quiet) to avoid the bottleneck, because it's faster to start over than wait. Conscious of this experience, I avoided the problem in tugz unzip without changing the user interface. You get a listing but you don't have to pay for it. $ unzip example.zip Archive: example.zip inflating: example.bmp inflating: example.svg inflating: example.txt Consider this C program that prints three lines: #include <stdio.h> int main() { puts("a\nb"); puts("c"); } If we examine the writes with, say, strace: $ strace -o log -e write ./a.out a b c We might see (here glibc): write(1, "a\n", 2) = 2 write(1, "b\n", 2) = 2 write(1, "c\n", 2) = 2 Yes, glibc takes line buffering quite literally, even splitting writes on a string. Some implementations are a little more sophisticated: write(1, "a\nb\n", 2) = 4 write(1, "c\n", 2) = 2 CPython makes exactly those writes for this program: import sys sys.stdout.write("a\nb\n") sys.stdout.write("c\n") Its rule is to flush if its buffer contains a newline after appen

## CVE-2026-57567 - Readest: Unscoped Tauri IPC download\_file/upload\_file allow arbitrary local file write and read from the webview

DevFeed: [CVE-2026-57567 - Readest: Unscoped Tauri IPC download\_file/upload\_file allow arbitrary local file write and read from the webview](<https://devfeed.tech/articles/cve-2026-57567-readest-unscoped-tauri-ipc-download-file-upload-file-allow-arbitrary-local-file-write-and-read-from-the-webview-117880.md>)

Original publisher: [Read original article](<https://cvefeed.io/vuln/detail/CVE-2026-57567>)

Author: CVEFEED.io; github.com

Published: 2026-11-04T22:18:07Z

Content type: news

Language: en

Sources: [Latest High/Critical Vulnerabilitiy Feed](<https://devfeed.tech/sources/latest-high-critical-vulnerabilitiy-feed.md>)

Topics: [Tauri](<https://devfeed.tech/topics/tauri.md>), [IO](<https://devfeed.tech/topics/io.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [cve](<https://devfeed.tech/tags/cve.md>), [cve-2026-57567](<https://devfeed.tech/tags/cve-2026-57567.md>), [download](<https://devfeed.tech/tags/download.md>), [file](<https://devfeed.tech/tags/file.md>), [ipc](<https://devfeed.tech/tags/ipc.md>), [tauri](<https://devfeed.tech/tags/tauri.md>), [upload](<https://devfeed.tech/tags/upload.md>), [webview](<https://devfeed.tech/tags/webview.md>), [write](<https://devfeed.tech/tags/write.md>)

### AI overview

In affected desktop Tauri builds before Readest 0.11.10, the download_file and upload_file IPC commands accepted webview-controlled paths and opened or created files without enforcing filesystem scope or blocking absolute paths and parent traversal. Because the commands were registered for the main, updater, and reader windows, JavaScript running in the privileged application origin could read files available to the process and send their contents, or write attacker-controlled data to writable paths. Exploitation requires such JavaScript execution, for example through application XSS or a compromised renderer; the source does not establish whether book-embedded JavaScript can reach the parent origin. Possible impacts include exposure of secrets and overwriting trusted or startup files. The issue is fixed in version 0.11.10.

### Source excerpt

CVE ID :CVE-2026-57567 Published : Nov. 4, 2026, 10:18 p.m. | 2 hours, 20 minutes ago Description :Readest is a modern, feature-rich ebook reader designed for seamless cross-platform access and an intuitive reading experience. In affected desktop Tauri builds prior to 0.11.10, the apps/readest-app/src-tauri/src/transfer_file.rs commands download_file and upload_file accepted a webview-controlled file_path and passed it to File::create or File::open without checking the Tauri filesystem scope, rejecting absolute paths, or blocking parent-directory traversal. The commands were registered in the global invoke handler for the main, updater, and reader-* windows, so JavaScript executing in the privileged application origin could write attacker-controlled content to any path writable by the process or read and send any path readable by the process. Exploitation requires JavaScript execution in that privileged origin, such as through an application XSS or compromised renderer; whether book-embedded JavaScript can reach the parent origin was not established. The write primitive can overwrite trusted or startup files, while the read primitive can expose keys, tokens, and application secrets. This issue is fixed in version 0.11.10. Severity: 8.6 | HIGH Visit the link for more details, such as CVSS details, affected products, timeline, and more...

## Reading Data from an Unwilling Blood Pressure Monitor

DevFeed: [Reading Data from an Unwilling Blood Pressure Monitor](<https://devfeed.tech/articles/reading-data-from-an-unwilling-blood-pressure-monitor-116087.md>)

Original publisher: [Read original article](<https://hackaday.com/2026/11/04/reading-data-from-an-unwilling-blood-pressure-monitor/>)

Author: Tom Nardi

Published: 2026-11-04T09:00:46Z

Content type: news

Language: en

Sources: [Hackaday](<https://devfeed.tech/sources/hackaday.md>)

Topics: [Image](<https://devfeed.tech/topics/image.md>), [IO](<https://devfeed.tech/topics/io.md>), [Decoding](<https://devfeed.tech/topics/decoding.md>)

Tags: [blood](<https://devfeed.tech/tags/blood.md>), [blood-pressure](<https://devfeed.tech/tags/blood-pressure.md>), [blood-pressure-monitor](<https://devfeed.tech/tags/blood-pressure-monitor.md>), [camera](<https://devfeed.tech/tags/camera.md>), [code](<https://devfeed.tech/tags/code.md>), [computer-vision](<https://devfeed.tech/tags/computer-vision.md>), [digital-cameras-hacks](<https://devfeed.tech/tags/digital-cameras-hacks.md>), [display-driver](<https://devfeed.tech/tags/display-driver.md>), [esp32](<https://devfeed.tech/tags/esp32.md>), [lcd](<https://devfeed.tech/tags/lcd.md>), [logic-analyzer](<https://devfeed.tech/tags/logic-analyzer.md>), [medical](<https://devfeed.tech/tags/medical.md>), [medical-hacks](<https://devfeed.tech/tags/medical-hacks.md>), [microcontroller](<https://devfeed.tech/tags/microcontroller.md>), [pcb](<https://devfeed.tech/tags/pcb.md>), [raw](<https://devfeed.tech/tags/raw.md>), [reverse-engineering](<https://devfeed.tech/tags/reverse-engineering.md>)

### AI overview

Tomasz Burzy modified a blood pressure monitor to send readings over WiFi without relying on a cloud account or subscription. He first probed the pressure sensor, but estimates from its raw data did not match the monitor's displayed result, which depends on an undocumented calculation. Intercepting the final value also failed because one integrated chip handled the display and other functions. He instead mounted a camera on an ESP32-CAM and read the LCD by checking known pixel coordinates for lit segments, avoiding the need for a computer vision system. The excerpt describes this as a practical workaround for extracting readings from a tightly integrated device.

### Source excerpt

Given the modern trend of interconnecting anything and everything, we have no doubt that somebody sells a blood pressure monitor that will push its measurements out to all sorts of ...read more

## Build an AI Voice Assistant with Twilio Voice and Media Streams, Rime's Prism, and Node.js

DevFeed: [Build an AI Voice Assistant with Twilio Voice and Media Streams, Rime's Prism, and Node.js](<https://devfeed.tech/articles/build-an-ai-voice-assistant-with-twilio-voice-and-media-streams-rime-s-prism-and-node-js-109680.md>)

Original publisher: [Read original article](<https://www.twilio.com/en-us/blog/developers/tutorials/integrations/voice-ai-agent-rime-prism-node>)

Author: Paul Kamp, Safdar Jaffari

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

Content type: tutorial

Language: en

Sources: [Twilio](<https://devfeed.tech/sources/twilio-blog.md>), [Twilio Blog](<https://devfeed.tech/sources/twilio-blog-2.md>)

Topics: [Conversational AI](<https://devfeed.tech/topics/conversational-ai.md>), [twilio api](<https://devfeed.tech/topics/twilio-api.md>), [function calling](<https://devfeed.tech/topics/function-calling.md>), [Chat Bot](<https://devfeed.tech/topics/chatbot.md>), [Fastify](<https://devfeed.tech/topics/fastify.md>), [IO](<https://devfeed.tech/topics/io.md>), [Learning](<https://devfeed.tech/topics/learning.md>)

Tags: [1-5](<https://devfeed.tech/tags/1-5.md>), [2](<https://devfeed.tech/tags/2.md>), [22](<https://devfeed.tech/tags/22.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-voice-assistant](<https://devfeed.tech/tags/ai-voice-assistant.md>), [build](<https://devfeed.tech/tags/build.md>), [developer-insights](<https://devfeed.tech/tags/developer-insights.md>), [media](<https://devfeed.tech/tags/media.md>), [model](<https://devfeed.tech/tags/model.md>), [node](<https://devfeed.tech/tags/node.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [phone](<https://devfeed.tech/tags/phone.md>), [rime](<https://devfeed.tech/tags/rime.md>), [speech](<https://devfeed.tech/tags/speech.md>), [speech-to-speech](<https://devfeed.tech/tags/speech-to-speech.md>), [streams](<https://devfeed.tech/tags/streams.md>), [twilio](<https://devfeed.tech/tags/twilio.md>), [using](<https://devfeed.tech/tags/using.md>), [voice](<https://devfeed.tech/tags/voice.md>), [voice-assistant](<https://devfeed.tech/tags/voice-assistant.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

The tutorial builds a Node.js phone assistant that connects Twilio Voice and bidirectional Media Streams to Rime's Prism speech-to-speech model. It requires Node.js 22+, Twilio and Rime accounts, a Voice-enabled number, and a public tunnel for local testing. The server uses Fastify and Rime's SDK; audio.js converts Twilio's 8 kHz G.711 μ-law audio to PCM16 for Prism and filters and downsamples Prism's 24 kHz PCM16 replies for Twilio. Media Streams marks track playback in 100 ms chunks so interruptions can report approximately how much of a reply the caller heard, subject to latency. An optional extension uses Twilio Conversation Intelligence to summarize and score sentiment after calls, and Conversation Memory to save and recall caller notes. The tutorial notes that memory lookup is time-limited and that recalled notes should be treated as caller-provided content, used only when relevant.

### Source excerpt

Build an AI voice assistant that answers phone calls, using Twilio Voice and Media Streams, Rime's Prism speech-to-speech model, and Node.js.

## How to Build a Command-Line Weather App with Python

DevFeed: [How to Build a Command-Line Weather App with Python](<https://devfeed.tech/articles/how-to-build-a-command-line-weather-app-with-python-105931.md>)

Original publisher: [Read original article](<https://www.freecodecamp.org/news/how-to-build-a-command-line-weather-app-with-python/>)

Author: Sameer Qaiser

Published: 2026-10-28T21:16:04Z

Content type: tutorial

Language: en

Sources: [Free Code Camp](<https://devfeed.tech/sources/freecodecamp-programming-tutorials-python-javascript-git-more.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [Terminal](<https://devfeed.tech/topics/terminal.md>), [console](<https://devfeed.tech/topics/console.md>), [IO](<https://devfeed.tech/topics/io.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [app](<https://devfeed.tech/tags/app.md>), [arguments](<https://devfeed.tech/tags/arguments.md>), [beginner-developers](<https://devfeed.tech/tags/beginner-developers.md>), [command-line](<https://devfeed.tech/tags/command-line.md>), [error-handling](<https://devfeed.tech/tags/error-handling.md>), [http](<https://devfeed.tech/tags/http.md>), [json](<https://devfeed.tech/tags/json.md>), [python](<https://devfeed.tech/tags/python.md>), [weather](<https://devfeed.tech/tags/weather.md>), [webdev](<https://devfeed.tech/tags/webdev.md>)

### AI overview

The tutorial builds a Python terminal app that accepts a city name, uses Open-Meteo's geocoding API to get the first matching coordinates, then requests current temperature at 2 meters and wind speed at 10 meters. It uses `requests` with a five-second timeout and HTTP error checks, parses JSON, and prints the results in Celsius and km/h. `sys.argv` handles city names with spaces; the script reports missing input, unknown cities, connection failures, and selected data-reading errors. Because it takes only the first geocoding match, ambiguous city names may resolve to the wrong place. Suggested extensions include humidity, a forecast, and choosing among multiple city matches.

### Source excerpt

After doing a few basic Python projects, I got a bit bored of programs that just take input and print something back. I wanted to make something that actually gets data from the internet. So, I built

## How to Extract Data from InnoDB, MyISAM, and MyRocks Files Without a Running Server

DevFeed: [How to Extract Data from InnoDB, MyISAM, and MyRocks Files Without a Running Server](<https://devfeed.tech/articles/how-to-extract-data-from-innodb-myisam-and-myrocks-files-without-a-running-server-105590.md>)

Original publisher: [Read original article](<https://www.percona.com/blog/how-to-extract-data-from-innodb-myisam-and-myrocks-files-without-a-running-server/>)

Author: Przemysław Malkowski

Published: 2026-10-28T13:13:49Z

Content type: article

Language: en

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

Topics: [Tool](<https://devfeed.tech/topics/tool.md>), [IO](<https://devfeed.tech/topics/io.md>), [Data Quality](<https://devfeed.tech/topics/data-quality.md>)

Tags: [backup-and-recovery](<https://devfeed.tech/tags/backup-and-recovery.md>), [backups](<https://devfeed.tech/tags/backups.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [bypass](<https://devfeed.tech/tags/bypass.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cases](<https://devfeed.tech/tags/cases.md>), [complex](<https://devfeed.tech/tags/complex.md>), [data](<https://devfeed.tech/tags/data.md>), [data-recovery](<https://devfeed.tech/tags/data-recovery.md>), [database](<https://devfeed.tech/tags/database.md>), [directories](<https://devfeed.tech/tags/directories.md>), [files](<https://devfeed.tech/tags/files.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [innodb](<https://devfeed.tech/tags/innodb.md>), [insight-for-dbas](<https://devfeed.tech/tags/insight-for-dbas.md>), [mariadb](<https://devfeed.tech/tags/mariadb.md>), [mysql](<https://devfeed.tech/tags/mysql.md>), [offline](<https://devfeed.tech/tags/offline.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [percona](<https://devfeed.tech/tags/percona.md>), [server](<https://devfeed.tech/tags/server.md>), [snapshots](<https://devfeed.tech/tags/snapshots.md>), [storage](<https://devfeed.tech/tags/storage.md>), [storage-engine](<https://devfeed.tech/tags/storage-engine.md>), [tool](<https://devfeed.tech/tags/tool.md>), [volume](<https://devfeed.tech/tags/volume.md>)

### AI overview

innodump is an experimental, open-source tool for extracting rows offline from InnoDB, MyISAM, and MyRocks files without a running MySQL or MariaDB server. It can dump whole data directories, selected tables, databases, or files to SQL or MySQL Shell-compatible TSV. The `--skip-corrupted` option skips damaged pages, while `--examine` reports readable and corrupted rows; examination scans clustered indexes only and does not detect secondary-index corruption. `--deleted-only` can recover rows still present as delete-marked records. Direct file reads are not a backup method and do not guarantee consistency: live or unprepared files may yield missing, stale, or incorrectly flagged rows, and recently created tables may be absent. For live exports, the article recommends limiting I/O with `--io-limit`, using `--direct-io` to bypass the OS page cache, and reducing CPU priority with `nice`. The project is not officially supported by Percona.

### Source excerpt

Probably everyone responsible for managing database servers at some point realizes that it would be helpful to have a tool capable of extracting data directly from raw database files. Something completely offline, without the need to have a running database server, and that would work with data directories, files, or binary backups (storage volume snapshots, ... Continued The post How to Extract Data from InnoDB, MyISAM, and MyRocks Files Without a Running Server appeared first on Percona.

## Linux's Modern NTFS Driver Now Supports Alternate Data Streams (ADS)

DevFeed: [Linux's Modern NTFS Driver Now Supports Alternate Data Streams (ADS)](<https://devfeed.tech/articles/linux-s-modern-ntfs-driver-now-supports-alternate-data-streams-ads-101966.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/NTFS-Linux-7.4-Improvements>)

Author: Michael Larabel

Published: 2026-10-27T10:11:29Z

Content type: news

Language: en

Sources: [Phoronix](<https://devfeed.tech/sources/phoronix.md>)

Topics: [Linux Kernel](<https://devfeed.tech/topics/linux-kernel.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [file](<https://devfeed.tech/topics/file.md>), [IO](<https://devfeed.tech/topics/io.md>), [mount](<https://devfeed.tech/topics/mount.md>)

Tags: [7-4](<https://devfeed.tech/tags/7-4.md>), [addition](<https://devfeed.tech/tags/addition.md>), [ads](<https://devfeed.tech/tags/ads.md>), [apple](<https://devfeed.tech/tags/apple.md>), [backup](<https://devfeed.tech/tags/backup.md>), [compatibility](<https://devfeed.tech/tags/compatibility.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [driver](<https://devfeed.tech/tags/driver.md>), [enumeration](<https://devfeed.tech/tags/enumeration.md>), [exploited](<https://devfeed.tech/tags/exploited.md>), [feature](<https://devfeed.tech/tags/feature.md>), [file-system](<https://devfeed.tech/tags/file-system.md>), [hidden](<https://devfeed.tech/tags/hidden.md>), [interface](<https://devfeed.tech/tags/interface.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [linux](<https://devfeed.tech/tags/linux.md>), [linux-7-4](<https://devfeed.tech/tags/linux-7-4.md>), [linux-benchmarking](<https://devfeed.tech/tags/linux-benchmarking.md>), [linux-hardware-benchmarks](<https://devfeed.tech/tags/linux-hardware-benchmarks.md>), [linux-hardware-reviews](<https://devfeed.tech/tags/linux-hardware-reviews.md>), [linux-how-to](<https://devfeed.tech/tags/linux-how-to.md>), [linux-performance](<https://devfeed.tech/tags/linux-performance.md>), [linux-server-benchmarks](<https://devfeed.tech/tags/linux-server-benchmarks.md>), [microsoft](<https://devfeed.tech/tags/microsoft.md>), [new-features](<https://devfeed.tech/tags/new-features.md>), [ntfs](<https://devfeed.tech/tags/ntfs.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [streams](<https://devfeed.tech/tags/streams.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

Linux 7.4 adds Alternate Data Stream support to the modern NTFS driver. New ioctl interfaces let user space enumerate, read, write, and remove streams (multiple $DATA attributes) on opened NTFS files. Mounting with `streams_interface=windows` also enables stream access through Windows-style `[file]:[stream-name]` paths. The excerpt notes other additions: file-flag queries and updates, volume serial number exposure through `FS_IOC_GETFSUUID`, hibernated-volume mounting, compatibility and validation improvements, and fixes. ADS can store extra metadata or file revisions, and has also been used to conceal malware.

### Source excerpt

Merged back in Linux 7.1 was the new NTFS kernel driver implementation for better supporting Microsoft's NTFS file-system on Linux. Since then new features and improvements have continued to land for this NTFS driver with some more notable additions also coming in Linux 7.4...

## Quake II for RP2350: HDMI, 8 MB PSRAM, USB keyboard and mouse, I2S audio

DevFeed: [Quake II for RP2350: HDMI, 8 MB PSRAM, USB keyboard and mouse, I2S audio](<https://devfeed.tech/articles/quake-ii-for-rp2350-hdmi-8-mb-psram-usb-keyboard-and-mouse-i2s-audio-100711.md>)

Original publisher: [Read original article](<https://blog.adafruit.com/2026/10/26/quake-ii-for-rp2350-hdmi-8-mb-psram-usb-keyboard-and-mouse-i2s-audio/>)

Author: Anne Barela

Published: 2026-10-26T18:52:03Z

Content type: news

Language: en

Sources: [Adafruit Industries](<https://devfeed.tech/sources/adafruit-industries-makers-hackers-artists-designers-and-engineers.md>)

Topics: [Raspberry Pi RP2350](<https://devfeed.tech/topics/raspberry-pi-rp2350.md>), [hdmi](<https://devfeed.tech/topics/hdmi.md>), [PSRAM](<https://devfeed.tech/topics/psram.md>), [USB](<https://devfeed.tech/topics/usb.md>), [IO](<https://devfeed.tech/topics/io.md>)

Tags: [audio](<https://devfeed.tech/tags/audio.md>), [gaming](<https://devfeed.tech/tags/gaming.md>), [hdmi](<https://devfeed.tech/tags/hdmi.md>), [keyboard](<https://devfeed.tech/tags/keyboard.md>), [mouse](<https://devfeed.tech/tags/mouse.md>), [psram](<https://devfeed.tech/tags/psram.md>), [quake-ii](<https://devfeed.tech/tags/quake-ii.md>), [raspberry-pi](<https://devfeed.tech/tags/raspberry-pi.md>), [rp2350](<https://devfeed.tech/tags/rp2350.md>)

### AI overview

The work-in-progress frank-quake2 port runs Quake II on RP2350 boards, with HDMI output on FRANK and Murmulator M2 via HSTX and on Waveshare RP2350-PiZero via PIO. Input uses a USB keyboard and mouse; audio is available over HDMI or through an I2S DAC. It is based on the ESP32-S3 Quake II port, with the software renderer and baseq2, and uses frank-castle's platform layer. Since 8 MB of PSRAM cannot hold the maps, models and skins are read from flash. First boot builds an approximately 14 MB image from pak files, takes about 90 seconds, and restarts; boards with 8 MB flash receive a smaller image that omits the largest assets. The repository does not include game data; a retail copy patched to version 3.20 is required.

### Source excerpt

Developer rh1tech has posted frank-quake2 on GitHub, a port of Quake II that runs on the RP2350. It targets the FRANK and Murmulator M2 boards, which output HDMI over HSTX, and the Waveshare RP2350-PiZero, which does HDMI through PIO. Sound comes out over HDMI or from an I2S DAC. A USB keyboard and mouse handle [...]

## How to Use Generators and yield in Python

DevFeed: [How to Use Generators and yield in Python](<https://devfeed.tech/articles/how-to-use-generators-and-yield-in-python-100532.md>)

Original publisher: [Read original article](<https://realpython.com/introduction-to-python-generators/>)

Author: Kyle Stratis

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

Content type: tutorial

Language: en

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

Topics: [yield](<https://devfeed.tech/topics/yield.md>), [Python](<https://devfeed.tech/topics/python.md>), [execution](<https://devfeed.tech/topics/execution.md>), [IO](<https://devfeed.tech/topics/io.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>)

Tags: [coroutine](<https://devfeed.tech/tags/coroutine.md>), [csv](<https://devfeed.tech/tags/csv.md>), [data](<https://devfeed.tech/tags/data.md>), [data-pipeline](<https://devfeed.tech/tags/data-pipeline.md>), [data-pipelines](<https://devfeed.tech/tags/data-pipelines.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [dict](<https://devfeed.tech/tags/dict.md>), [functions](<https://devfeed.tech/tags/functions.md>), [generator](<https://devfeed.tech/tags/generator.md>), [generators](<https://devfeed.tech/tags/generators.md>), [lazy](<https://devfeed.tech/tags/lazy.md>), [python](<https://devfeed.tech/tags/python.md>), [statement](<https://devfeed.tech/tags/statement.md>), [yield](<https://devfeed.tech/tags/yield.md>)

### AI overview

Python generators are lazy iterators that yield values on demand, retaining a function's state between calls and avoiding storage of the full result in memory. The article contrasts a CSV reader that loads all lines with one that yields them individually, then shows generator expressions and a chain of generators that reads, splits, filters and totals Series A funding data. It also demonstrates infinite sequences, repeated next() calls, and the generator methods send(), throw() and close(). Generators can save substantial memory, though the article's example reports list comprehensions as faster when memory is not a constraint. Its hand-built CSV pipeline is for teaching; the article recommends Python's csv module for actual CSV parsing.

### Source excerpt

Build generator functions and generator expressions with the Python yield statement, and learn when lazy evaluation pays off.

## CVE-2026-97200 - Unbounded response body buffering and decompression in hackney

DevFeed: [CVE-2026-97200 - Unbounded response body buffering and decompression in hackney](<https://devfeed.tech/articles/cve-2026-97200-unbounded-response-body-buffering-and-decompression-in-hackney-100485.md>)

Original publisher: [Read original article](<https://cvefeed.io/vuln/detail/CVE-2026-97200>)

Author: cvefeed.io

Published: 2026-10-26T13:49:40Z

Content type: news

Language: en

Sources: [Latest High/Critical Vulnerabilitiy Feed](<https://devfeed.tech/sources/latest-high-critical-vulnerabilitiy-feed.md>)

Topics: [client](<https://devfeed.tech/topics/client.md>), [Streaming](<https://devfeed.tech/topics/streaming.md>), [IO](<https://devfeed.tech/topics/io.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [benoitc](<https://devfeed.tech/tags/benoitc.md>), [cve](<https://devfeed.tech/tags/cve.md>), [cve-2026-97200](<https://devfeed.tech/tags/cve-2026-97200.md>), [hackney](<https://devfeed.tech/tags/hackney.md>), [http](<https://devfeed.tech/tags/http.md>), [http-2](<https://devfeed.tech/tags/http-2.md>), [http-3](<https://devfeed.tech/tags/http-3.md>), [http-server](<https://devfeed.tech/tags/http-server.md>), [limits](<https://devfeed.tech/tags/limits.md>), [malicious](<https://devfeed.tech/tags/malicious.md>), [memory](<https://devfeed.tech/tags/memory.md>), [process](<https://devfeed.tech/tags/process.md>), [request](<https://devfeed.tech/tags/request.md>), [server](<https://devfeed.tech/tags/server.md>), [trigger](<https://devfeed.tech/tags/trigger.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>), [with](<https://devfeed.tech/tags/with.md>), [zlib](<https://devfeed.tech/tags/zlib.md>)

### AI overview

CVE-2026-97200 allows a malicious HTTP server to exhaust hackney client memory with an oversized or highly compressed response. `hackney:request/5` and `hackney:body/1` return the entire body, while the connection process and HTTP/2 and HTTP/3 accumulators append chunks without a stated size limit. With `{auto_decompress, true}`, the buffered body is inflated all at once by `zlib:gunzip/1` or `zlib:inflate/2`. The reported affected range is hackney 2.0.0-beta.1 through versions before 4.9.0; the supplied text does not describe a fix or mitigation.

### Source excerpt

CVE ID :CVE-2026-97200 Published : Oct. 26, 2026, 1:49 p.m. | 14 minutes ago Description :Allocation of Resources Without Limits or Throttling vulnerability in hackney_conn in benoitc hackney allows a malicious HTTP server to exhaust client memory via an oversized or highly compressed response body. hackney:request/5 and hackney:body/1 return the whole response body, and nothing bounds how much the connection process buffers. Any server the client requests can trigger it. hackney_conn:read_full_body/2 and the HTTP/2 and HTTP/3 accumulators append every chunk until the body ends. With {auto_decompress, true} the buffered body is then inflated in one step with zlib:gunzip/1 or zlib:inflate/2, which return the whole output at once. This issue affects hackney: from 2.0.0-beta.1 before 4.9.0. Severity: 8.2 | HIGH Visit the link for more details, such as CVSS details, affected products, timeline, and more...

## Vercel Sandbox commands now support stdin

DevFeed: [Vercel Sandbox commands now support stdin](<https://devfeed.tech/articles/vercel-sandbox-commands-now-support-stdin-100657.md>)

Original publisher: [Read original article](<https://vercel.com/changelog/vercel-sandbox-commands-now-support-stdin>)

Author: Kishore Devireddy

Published: 2026-10-26T06:00:00Z

Content type: release

Language: en

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

Topics: [IO](<https://devfeed.tech/topics/io.md>), [Vercel](<https://devfeed.tech/topics/vercel.md>), [Python](<https://devfeed.tech/topics/python.md>), [Agent Browser](<https://devfeed.tech/topics/agent-browser.md>)

Tags: [agent-browser](<https://devfeed.tech/tags/agent-browser.md>), [command-line](<https://devfeed.tech/tags/command-line.md>), [commands](<https://devfeed.tech/tags/commands.md>), [data](<https://devfeed.tech/tags/data.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [input](<https://devfeed.tech/tags/input.md>), [js](<https://devfeed.tech/tags/js.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [mcp-servers](<https://devfeed.tech/tags/mcp-servers.md>), [messages](<https://devfeed.tech/tags/messages.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [process](<https://devfeed.tech/tags/process.md>), [python](<https://devfeed.tech/tags/python.md>), [python-sdk](<https://devfeed.tech/tags/python-sdk.md>), [sandbox](<https://devfeed.tech/tags/sandbox.md>), [sdk](<https://devfeed.tech/tags/sdk.md>), [send](<https://devfeed.tech/tags/send.md>), [server](<https://devfeed.tech/tags/server.md>), [typescript](<https://devfeed.tech/tags/typescript.md>), [vercel](<https://devfeed.tech/tags/vercel.md>)

### AI overview

Vercel Sandbox supports sending stdin to running commands. In the TypeScript SDK, set `stdin: true` and `detached: true` in `runCommand()`, then use `writeStdin()` and `closeStdin()`; stdin can also be a Node.js readable stream, which is forwarded until it ends. In the Python SDK, create a process with `stdin=subprocess.PIPE`, send data with `server.stdin.send()`, and call `communicate()` to close stdin, collect remaining output, and wait for exit. For input supplied all at once, Python's `run_process()` accepts an `input` argument. The text gives stdio MCP servers as one use case.

### Source excerpt

Vercel Sandbox now lets you send input to running commands through standard input (stdin). Use it to exchange messages with stdio MCP servers such as agent-browser, or send data to other command-line programs while they run. In the TypeScript SDK, set stdin: true and detached: true in runCommand(). Use writeStdin() to send input and closeStdin() when you're done: You can also set stdin to a Node.js readable stream, such as process.stdin. The SDK forwards the stream's data and closes the command's standard input when the stream ends. In the Python SDK, set stdin=subprocess.PIPE and send input with server.stdin.send(). Call communicate() to close stdin, collect remaining output, and wait for the process to exit: For commands that receive all their input at once, you can pass input directly to Python's run_process(). Read the Sandbox documentation to get started. Read more

## Approaching I/O-optimality for Approximate Attention

DevFeed: [Approaching I/O-optimality for Approximate Attention](<https://devfeed.tech/articles/approaching-i-o-optimality-for-approximate-attention-99414.md>)

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

Author: P\\'al Andr\\'as Papp, Aleksandros Sobczyk, Anastasios Zouzias

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

Content type: article

Language: en

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

Topics: [Transformer](<https://devfeed.tech/topics/transformer.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [IO](<https://devfeed.tech/topics/io.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [attention](<https://devfeed.tech/tags/attention.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [computer-science](<https://devfeed.tech/tags/computer-science.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [flashattention](<https://devfeed.tech/tags/flashattention.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [lower-bound](<https://devfeed.tech/tags/lower-bound.md>), [lower-bounds](<https://devfeed.tech/tags/lower-bounds.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [matrices](<https://devfeed.tech/tags/matrices.md>), [matrix](<https://devfeed.tech/tags/matrix.md>), [memory](<https://devfeed.tech/tags/memory.md>), [neurips](<https://devfeed.tech/tags/neurips.md>)

### AI overview

The paper proposes I/O-efficient algorithms for approximate attention that reduce data-transfer dependence on context length from quadratic to almost linear, building on Alman and Song's method. It also gives algorithm-specific lower bounds across parameter regimes that nearly match the corresponding upper bounds, suggesting the algorithms are close to I/O-optimal. The supplied evidence is an abstract and does not specify the algorithms' precise costs or regimes.

### Source excerpt

arXiv:2605.23751v2 Announce Type: replace Abstract: We revisit the I/O complexity of attention in large language models. Given query-key-value matrices $Q,K,V\in\mathbb{R}^{n\times d}$, and a machine with fast memory size $M$, the goal is to compute the "attention matrix" $A=\text{softmax}(Q K ^{\top}/\sqrt{d}) V$ with the minimal number of data transfers between fast and slow memory. Existing methods in the literature, most notably FlashAttention and its variants, incur an I/O cost that depends quadratically on the context length $n$, while a trivial lower bound only requires $\Omega(nd)$ I/O's to read the inputs and write the output. In this work we show that the dependence on $n$ can be reduced to almost-linear, by developing I/O-efficient algorithms inspired by the recent approximate attention method of Alman and Song [NeurIPS'23]. We also provide (algorithm-specific) lower bounds in different parameter regimes, which nearly match the corresponding upper bounds, indicating that the proposed algorithms are indeed close to I/O-optimal.

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