# Functional programming

In computer science, functional programming is a programming paradigm where programs are constructed by applying and composing functions. It is a declarative programming paradigm in which function definitions are trees of expressions that map values to other values, rather than a sequence of imperative statements which update the running state of the program.

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

## Algorithmic Market Making Can Lead to Rough Volatility Through the Order Book

DevFeed: [Algorithmic Market Making Can Lead to Rough Volatility Through the Order Book](<https://devfeed.tech/articles/algorithmic-market-making-can-lead-to-rough-volatility-through-the-order-book-143474.md>)

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

Author: Sai Niranjan Ramachandran

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

Content type: article

Language: en

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

Topics: [Finance](<https://devfeed.tech/topics/finance.md>), [Data analysis](<https://devfeed.tech/topics/data-analysis.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [batch](<https://devfeed.tech/tags/batch.md>), [binance](<https://devfeed.tech/tags/binance.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [flow](<https://devfeed.tech/tags/flow.md>), [gradient](<https://devfeed.tech/tags/gradient.md>), [gradient-descent](<https://devfeed.tech/tags/gradient-descent.md>), [horizon](<https://devfeed.tech/tags/horizon.md>), [information](<https://devfeed.tech/tags/information.md>), [maker](<https://devfeed.tech/tags/maker.md>), [market-making](<https://devfeed.tech/tags/market-making.md>), [memory](<https://devfeed.tech/tags/memory.md>), [model](<https://devfeed.tech/tags/model.md>), [oracle](<https://devfeed.tech/tags/oracle.md>), [orders](<https://devfeed.tech/tags/orders.md>), [power](<https://devfeed.tech/tags/power.md>), [q-fin-mf](<https://devfeed.tech/tags/q-fin-mf.md>), [q-fin-tr](<https://devfeed.tech/tags/q-fin-tr.md>), [scaling](<https://devfeed.tech/tags/scaling.md>), [volume](<https://devfeed.tech/tags/volume.md>)

### AI overview

The paper proposes that asynchronous market makers can generate rough volatility through order-book dynamics. Each desk adjusts order distances toward oracle-supplied targets using a first-order gradient rule, acting when relevant information arrives over its own lookback horizon. Collectively, these updates resemble stochastic gradient descent with information-driven noise. In the continuum limit, book volume follows the Dean-Kawasaki equation; its fluctuations drive order flow, while varied desk horizons produce power-law memory that leads, through scaling arguments, to rough volatility. The authors report support from simulated agents and six months of Binance data comprising about 790 million orders, with Binance perpetual futures' order books consistent with the modeled changes. The abstract presents this as one mechanism, not a complete account of market behavior.

### Source excerpt

arXiv:2611.24028v1 Announce Type: new Abstract: Existing work suggests that markets can show volatility with paths rougher than those of Brownian motion. In theory this can happen when the order flow is close to instability with memory that decays as a power law. However, it is not fully clear how such order flow could arise from the predominantly algorithmic market making that characterizes order book dynamics. We show one such consistent mechanism. We treat each market maker as a desk that uses a first-order gradient rule to move the distances of its orders from the mid price toward target distances provided by an unknown oracle. We assume that distinct desks do not act synchronously in time but act whenever new information relevant to their respective oracles arrives, which each desk samples over its own characteristic lookback horizon. Across all desks the rule therefore takes the form of stochastic gradient descent (SGD) with information-driven (mini-batch) noise. In the continuum limit this update rule makes the volume of the order book follow a conservative stochastic partial differential equation (the Dean--Kawasaki equation) whose fluctuations drive the order flow. The distinct horizons of the desks further induce a persistent memory in the order flow that decays as a power law. Standard scaling arguments then lead to rough volatility. We confirm the key predictions of the model on simulated agents and on six months of Binance data with about 790 million orders. In liquid markets governed mainly by market makers, such as the perpetual futures of Binance, the order books are consistent with how our desks change the book.

## Python Code Generation for Isabelle/HOL

DevFeed: [Python Code Generation for Isabelle/HOL](<https://devfeed.tech/articles/python-code-generation-for-isabelle-hol-139611.md>)

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

Author: Nikolaus Huber, Roly Perera, Dominic Orchard

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

Content type: article

Language: en

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

Topics: [Isabelle/HOL proof assistant](<https://devfeed.tech/topics/isabelle-hol-proof-assistant.md>), [Python](<https://devfeed.tech/topics/python.md>), [Compilers and Linkers](<https://devfeed.tech/topics/compilers-and-linkers.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [OCaml](<https://devfeed.tech/topics/ocaml.md>)

Tags: [code-generation](<https://devfeed.tech/tags/code-generation.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [data-structures-and-algorithms](<https://devfeed.tech/tags/data-structures-and-algorithms.md>), [isabelle](<https://devfeed.tech/tags/isabelle.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

The work adds a Python backend to Isabelle/HOL's code generator, allowing functions in Isabelle's executable logic to be generated for use in Python applications. It also enables verified implementations to act as references for differential testing of established Python libraries. The authors report validation with regression suites covering large parts of the HOL library and tests of six verified data structures and algorithms against existing Python libraries. Generated code is slower than hand-written libraries, so the abstract presents it as particularly suitable for a verified reference.

### Source excerpt

arXiv:2611.22613v1 Announce Type: cross Abstract: The Isabelle theorem prover provides an environment for formalising mathematics and reasoning about programs. To make verified implementations practically usable, its code generator translates functions expressed in the executable fragment of its logic into conventional programming languages. Its targets have traditionally been functional languages (Standard ML, OCaml, Haskell, and Scala), recently joined by Go. Python, which is becoming the dominant language of scientific computing, data science, and education, has remained out of reach. In this work, we close this gap with a Python backend for Isabelle's code generator. This generator enables verified algorithms to be used in Python applications, or to serve as verified references against which established Python libraries can be differentially tested, without leaving the Python ecosystem. We validate the backend on regression suites covering large parts of the HOL library and by testing six verified data structures and algorithms against established Python libraries. The generated code is slower than hand-written libraries, but well suited as a verified reference.

## User-Schedulable Approximations for Quantized Tensor Programs

DevFeed: [User-Schedulable Approximations for Quantized Tensor Programs](<https://devfeed.tech/articles/user-schedulable-approximations-for-quantized-tensor-programs-135792.md>)

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

Author: Alex Reinking

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

Content type: article

Language: en

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

Topics: [ggml](<https://devfeed.tech/topics/ggml.md>), [LLM optimization](<https://devfeed.tech/topics/llm-optimization.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Arm](<https://devfeed.tech/topics/arm.md>), [x86](<https://devfeed.tech/topics/x86.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [activation](<https://devfeed.tech/tags/activation.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [apple](<https://devfeed.tech/tags/apple.md>), [approximation](<https://devfeed.tech/tags/approximation.md>), [arm](<https://devfeed.tech/tags/arm.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [block](<https://devfeed.tech/tags/block.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [cases](<https://devfeed.tech/tags/cases.md>), [code](<https://devfeed.tech/tags/code.md>), [codec](<https://devfeed.tech/tags/codec.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [covering](<https://devfeed.tech/tags/covering.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cpus](<https://devfeed.tech/tags/cpus.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-pf](<https://devfeed.tech/tags/cs-pf.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [decoder](<https://devfeed.tech/tags/decoder.md>), [devices](<https://devfeed.tech/tags/devices.md>), [user](<https://devfeed.tech/tags/user.md>)

### AI overview

The work extends Halide so quantization codecs--paired encoders and decoders built from reusable quantizers, integer representations, bit packers, and layouts--can be applied to program stages and scheduled like ordinary computation. Property-tested contracts can catch representation errors; a round-trip law exposed an inconsistent block sum in GGML's q8_1. One algorithm and schedule library generates 347 kernels for 31 GGML and KleidiAI formats on Arm CPUs and Apple GPUs, covering 38 weight-activation pairs without GGML kernels, using 3.7x less code than GGML and KleidiAI. On Apple M3 Max, the kernels reach at least 95% of GGML's format-specific kernel speed in 91.0% of comparable cases, with 1.13x median speedup; including Apple BLAS lowers the threshold share to 86.9% of CPU cases. An x86 port with Intel AMX adds 793 lines and matches GGML in 83.5% of its cases.

### Source excerpt

arXiv:2611.17526v1 Announce Type: cross Abstract: Quantization lets language models run on edge devices, but it sharply increases the number of tensor kernels a library must maintain: every weight format must be paired with every activation format on every instruction set and GPU, with an encoder and a decoder that agree on the stored bytes. In GGML, the tensor library used by llama.cpp, these kernels are written by hand, and only 8 of the 54 weight-activation pairs it runs on our Arm CPU have a tiled matrix-multiplication kernel. We extend Halide's separation of algorithm and schedule to the representation of values. Each approximation is a codec, an encoder paired with a decoder, composed from reusable units: quantizers, integer representations, bit packers and layouts. A new directive, approximate_by, applies a codec to one stage of a program and returns the encoder and decoder as ordinary stages that Halide can schedule, so both decoders fuse into the register tiles of a matrix product. Optional contracts, such as a round-trip law, are checked by property tests; the law exposed an inconsistent block sum in GGML's q8_1. One algorithm and one schedule library generate 347 kernels for 31 of GGML's and KleidiAI's formats on Arm CPUs and Apple GPUs, covering 38 weight-activation pairs for which GGML has no kernel, in 3.7x less code than GGML and KleidiAI. On an Apple M3 Max, our kernels reach at least 95% of the speed of GGML's format-specific kernels in 91.0% of the cases that have one, with a median speedup of 1.13x, and are faster still where GGML falls back to blocked dot products. Counting Apple's BLAS library, which is usually faster for larger f32 products, we still reach that threshold in 86.9% of CPU cases. A port to x86 with Intel's AMX adds 793 lines of code and matches GGML in 83.5% of its cases.

## Proof automation in a language

DevFeed: [Proof automation in a language](<https://devfeed.tech/articles/proof-automation-in-a-language-135925.md>)

Original publisher: [Read original article](<http://www.imperialviolet.org/2026/11/15/proofauto2.html>)

Author: Adam Langley

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

Content type: article

Language: en

Sources: [ImperialViolet](<https://devfeed.tech/sources/imperialviolet.md>)

Topics: [Lean](<https://devfeed.tech/topics/lean.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>)

Tags: [automation](<https://devfeed.tech/tags/automation.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [design](<https://devfeed.tech/tags/design.md>), [functional](<https://devfeed.tech/tags/functional.md>), [language](<https://devfeed.tech/tags/language.md>), [local](<https://devfeed.tech/tags/local.md>), [mutation](<https://devfeed.tech/tags/mutation.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [python](<https://devfeed.tech/tags/python.md>), [quality](<https://devfeed.tech/tags/quality.md>), [semantics](<https://devfeed.tech/tags/semantics.md>), [software](<https://devfeed.tech/tags/software.md>), [tradeoffs](<https://devfeed.tech/tags/tradeoffs.md>)

### AI overview

The experimental language combines mutable value semantics, contracts, refinement types, and literate programming to make code easier to reason about and verify with proof automation. Its restricted references are intended to reduce aliasing complexity and enable translation to Lean without separation logic; contracts specify behavior such as strict DER tag parsing, so readers can rely on a function's guarantees without inspecting its body. Arithmetic overflow, casts, indices, invariants, postconditions, and termination generate verification conditions. Z3 and cvc5 propose results, but Lean checks proofs; an LLM can write manual Lean proofs when automation times out. The tradeoff is substantial compute: the DER example produces 149 conditions, checks run at roughly 10 lines per second, and rechecking medium programs can take hours. The compiler front end and LLVM translation remain trusted parts of the system.

### Source excerpt

As I wrote previously, we have proof automation now. Given that fact, I think a very timely question is: how can we use it to improve software quality? The same machines that can write these proofs can also write large amounts of code. So an adjacent question is: how can we use them to improve software understandability? It would be a mistake to start off afresh on those problems because there have been a lot of ideas in programming language design over the decades. The viability of ideas shifts as the underlying cost structures change, so things that didn't take off at the time might suddenly make a lot more sense. Still, language design involves a lot of tradeoffs, and features sometimes interact in surprising ways, so a lot of the work involves mixing some interesting-seeming ingredients together, baking, and asking "what is this? Is this a cake?". So I wanted to give a taste of some of the ingredients that I'm thinking about at the moment, and of the result. Ingredients Mutable Value Semantics Value semantics roughly says that you can't observe mutations to one variable through a different name. Value semantics are great for reasoning locally about code as, without them, you're constantly unsure what non-local effects might be happening. When you work in a language, you instinctively know when it's using value semantics and when it's using reference semantics. Take Python: x = [1] y = x y[0] = 2 print(x) You likely know that that prints [2]. (Although if you write the same program in C++ with std::vector it prints [1]! There's no cross-language norm for this.) Over the span of four lines of code, this is irrelevant. But as the scope of the sharing increases, so does the mental complexity. If you want to be able to jump into a bit of code and understand what it's doing, knowing that there is no such aliasing is a huge boon. Functional programming resolves this by eliminating mutation: if there's no mutation then you certainly can't observe mutations via a differe

## 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 ...

## Representing Tensors as Compositions for Efficient Computation on Sparse and Structured Data

DevFeed: [Representing Tensors as Compositions for Efficient Computation on Sparse and Structured Data](<https://devfeed.tech/articles/representing-tensors-as-compositions-for-efficient-computation-on-sparse-and-structured-data-125265.md>)

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

Author: Val\\'erian Rey, Praneth Paruchuri

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

Content type: article

Language: en

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

Topics: [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [ggml](<https://devfeed.tech/topics/ggml.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [activation](<https://devfeed.tech/tags/activation.md>), [activation-function](<https://devfeed.tech/tags/activation-function.md>), [algebra](<https://devfeed.tech/tags/algebra.md>), [all](<https://devfeed.tech/tags/all.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [based](<https://devfeed.tech/tags/based.md>), [can](<https://devfeed.tech/tags/can.md>), [combined](<https://devfeed.tech/tags/combined.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [composition](<https://devfeed.tech/tags/composition.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-ms](<https://devfeed.tech/tags/cs-ms.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [data](<https://devfeed.tech/tags/data.md>), [draft](<https://devfeed.tech/tags/draft.md>), [element](<https://devfeed.tech/tags/element.md>), [engine](<https://devfeed.tech/tags/engine.md>), [focus](<https://devfeed.tech/tags/focus.md>), [structured](<https://devfeed.tech/tags/structured.md>), [structured-data](<https://devfeed.tech/tags/structured-data.md>), [tensors](<https://devfeed.tech/tags/tensors.md>)

### AI overview

The paper proposes representing tensors as index-to-value functions and tensor operations as compositions: value functions handle element-wise operations, index functions handle re-indexing, and combined index and reduction functions handle reductions. With tensor stacking, this is intended to cover dense, jagged, sparse, and factorized tensors, plus lazy forms of operations such as einsum. Algebraic identities can rewrite computations without evaluating them; for example, the product of two sparse matrices can be rewritten to compute only products of nonzero values. The authors propose using this algebra as a computation engine's intermediate representation, shifting implementation work toward index-function algebra. They project codebase complexity changing from O(mn²) to O(m + k²), where m is the number of binary tensor operations, n the number of tensor types, and k the number of index-function types. The supplied abstract mentions a draft implementation but gives no performance evaluation.

### Source excerpt

arXiv:2611.10855v1 Announce Type: new Abstract: We propose a new mathematical formalism in which all kinds of tensors and of operations on those tensors are represented as simple function compositions. Tensors are functions from indices to values. An element-wise operation (e.g. an activation function) is a composition with a function applied to values; re-indexing (e.g. reshape, transposition) is a composition with a function applied to indices; and a reduction is a composition with both an index function, mapping each index to several indices, and a reduction operation (e.g. product, sum, max). Combined with tensor stacking, these compositions can represent most interesting kinds of tensors (e.g. dense, jagged, all kinds of sparsity patterns, matrix factorizations), as well as lazy versions of almost every operation available in modern tensor computation frameworks, including einsums between tensors of any kind. Identities between compositions can then be used to rewrite such expressions into equivalent ones, without evaluating them. For instance, the product of two sparse matrices can be rewritten so that only products between non-zero values are computed, turning a sparse problem into a dense one. Using this algebra as the intermediate representation of a tensor computation engine would shift the focus from defining operations on tensors (e.g. einsum between sparse tensors) to defining an algebra on index functions. This should reduce the codebase complexity from $\mathcal{O}(mn^2)$, with $m$ the number of binary operations between tensors and $n$ the number of tensor types, to $\mathcal{O}(m + k^2)$, with $k$ the number of types of index functions. A draft implementation of a tensor computation framework based on this algebra is publicly available.

## Porting Declarative UI to HarmonyOS: A Heuristic-guided Approach for lightweight LLMs

DevFeed: [Porting Declarative UI to HarmonyOS: A Heuristic-guided Approach for lightweight LLMs](<https://devfeed.tech/articles/porting-declarative-ui-to-harmonyos-a-heuristic-guided-approach-for-lightweight-llms-127191.md>)

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

Author: Kunwu Zheng, Pengyu Xue, Zhen Yang, Tianlong Chen, Xiran Lyu, Peishi Lai, Mengying Zhao, Junjie Chen, Yutian Tang, Huizhi Zhang, Xianhang Li, Linhao Wu, Chengyi Wang

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

Content type: article

Language: en

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

Topics: [SwiftUI](<https://devfeed.tech/topics/swiftui.md>), [open-harmony](<https://devfeed.tech/topics/open-harmony.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [apis](<https://devfeed.tech/tags/apis.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [colors](<https://devfeed.tech/tags/colors.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [declarative](<https://devfeed.tech/tags/declarative.md>), [declarative-ui](<https://devfeed.tech/tags/declarative-ui.md>), [framework](<https://devfeed.tech/tags/framework.md>), [harmonyos](<https://devfeed.tech/tags/harmonyos.md>), [lightweight](<https://devfeed.tech/tags/lightweight.md>), [llms](<https://devfeed.tech/tags/llms.md>), [repair](<https://devfeed.tech/tags/repair.md>), [resource](<https://devfeed.tech/tags/resource.md>)

### AI overview

Direct KJC/SwiftUI-to-ArkUI translation had a 0-35% compilation success rate across nine setups. Screenshots and compiler-guided repair raised capable setups to 94-99%, but did not work well for lightweight LLMs. Analysis identified broken UI structure, nonexistent APIs, and missing resources as recurring error roots. ArkTrans addresses these with metadata extraction, deterministic skeleton construction, injected ArkUI and resource references, and compiler-guided iterative repair. With Qwen3.6-27B, it achieved 70% CSR for KJC and 64% for SwiftUI, plus 65.63% and 80% on real-world pages, respectively, at lower token cost than the best common strategy. The excerpt reports strong visual fidelity but gives no quantitative fidelity measure.

### Source excerpt

arXiv:2606.07085v3 Announce Type: replace Abstract: As an emerging operating system, HarmonyOS has a significant demand for software migration, where the User Interface (UI) translation accounts for a critical link. However, recent UI development has shifted to declarative paradigms, e.g., Kotlin Jetpack Compose (KJC) for Android, SwiftUI for iOS, and ArkUI for HarmonyOS, making prior translation approaches inapplicable because they target either backend logic or legacy imperative UIs. Thus, related research is limited. To systematically evaluate KJC/SwiftUI-to-ArkUI migration, we build a parallel benchmark of 100 KJC and 100 SwiftUI files across eight scenarios, plus 52 real-world UI pages from nine open-source apps. Evaluating nine direct-translation setups (including diverse LLMs and agents), we find Compilation Success Rate (CSR) spans 0.00%-35.00%; common strategies (reference screenshots and compiler-guided repair) lift capable setups to 94.00%-99.00% CSR but fail on lightweight LLMs. By manually analyzing a 3,102-sample subset, deriving a regular-expression pattern for each failure family, and applying these patterns to generalize the resulting taxonomy to the full 29,593-sample set, we find residual errors rooted in (1) broken structure, (2) nonexistent APIs, and (3) missing resources (e.g., colors, strings, and icons). Accordingly, we propose ArkTrans, a declarative UI translation framework that maps these roots to deterministic structure supply, ArkUI knowledge and resource reference injection via a demonstration example, and iterative repair targeting residual errors, via four steps: Metadata Extraction, Skeleton Construction, LLM-driven Translation, and Compiler-Guided Iterative Repair. With Qwen3.6-27B, ArkTrans raises CSR from 0.00% to 70.00% on KJC and 64.00% on SwiftUI, achieving strong visual fidelity, and attains 65.63%/80.00% CSR on real-world pages, far outperforming the best common strategy at lower token cost.

## Self-Programmed Execution for Language-Model Agents

DevFeed: [Self-Programmed Execution for Language-Model Agents](<https://devfeed.tech/articles/self-programmed-execution-for-language-model-agents-124406.md>)

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

Author: Luke J. O'Connor

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

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [execution](<https://devfeed.tech/topics/execution.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-tasks](<https://devfeed.tech/tags/agentic-tasks.md>), [agents](<https://devfeed.tech/tags/agents.md>), [completion](<https://devfeed.tech/tags/completion.md>), [content](<https://devfeed.tech/tags/content.md>), [context](<https://devfeed.tech/tags/context.md>), [context-window](<https://devfeed.tech/tags/context-window.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [effects](<https://devfeed.tech/tags/effects.md>), [execution](<https://devfeed.tech/tags/execution.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [frontier](<https://devfeed.tech/tags/frontier.md>), [frontier-models](<https://devfeed.tech/tags/frontier-models.md>), [harness](<https://devfeed.tech/tags/harness.md>), [language](<https://devfeed.tech/tags/language.md>), [language-model](<https://devfeed.tech/tags/language-model.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [policy](<https://devfeed.tech/tags/policy.md>), [program](<https://devfeed.tech/tags/program.md>), [results](<https://devfeed.tech/tags/results.md>)

### AI overview

Self-programmed execution (SPE) makes a language model's completion the agent's orchestrator: the harness evaluates the program but imposes no fixed orchestration policy. The paper introduces Spell, a Lisp dialect designed for this setup, where source code also serves as the model's context. Spell lets programs edit and re-evaluate themselves while structuring effectful operations, such as model calls, so re-evaluation does not replay their side effects. Experiments report that existing frontier models, despite not being trained for SPE or Spell, can learn Spell in context and complete challenging agentic tasks. The abstract does not detail the tasks or compare performance with other agent systems.

### Source excerpt

arXiv:2605.06898v3 Announce Type: replace Abstract: At the heart of a language model agent is an orchestrator program which is responsible for the state transition between consecutive turns. In existing systems, this program is implemented in the harness. This paper introduces self-programmed execution (SPE), in which the model completion is itself the orchestrator program, and the harness evaluates this program but does not impose any fixed orchestration policy. Formally, an SPE state of an agentic machine is one from which a model completion can load any successor state up to an embedding, and an instance of an SPE state is one which executes the model completion as a program. In practice, the program requires a language with unusual features, as its source code doubles as the content of the model's context window. I therefore introduce Spell, a Lisp dialect in which programs can edit and re-evaluate themselves, and effectful expressions like model invocations are structured such that re-evaluating an edited program does not replay its side effects. Experiments with existing models, not trained for SPE or Spell, show that frontier models can learn Spell in-context and accomplish challenging agentic tasks. These results demonstrate how an LM can act as an agent without any fixed orchestration policy, and they raise the question of what self-orchestration strategies might be learned by a model trained for self-programmed execution. Code is available at https://github.com/lukejoconnor/spell.

## Recognizing Policy

DevFeed: [Recognizing Policy](<https://devfeed.tech/articles/recognizing-policy-122371.md>)

Original publisher: [Read original article](<https://ryanharter.com/blog/2026/11/recognizing-policy/>)

Published: 2026-11-07T14:55:43Z

Content type: article

Language: en

Sources: [Blogs on Ryan Harter](<https://devfeed.tech/sources/blogs-on-ryan-harter.md>)

Topics: [Dynamic authorization rules](<https://devfeed.tech/topics/dynamic-authorization-rules.md>), [business logic](<https://devfeed.tech/topics/business-logic.md>), [policy-as-code](<https://devfeed.tech/topics/policy-as-code.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [business-logic](<https://devfeed.tech/tags/business-logic.md>), [chat](<https://devfeed.tech/tags/chat.md>), [cross-platform](<https://devfeed.tech/tags/cross-platform.md>), [feature](<https://devfeed.tech/tags/feature.md>), [file-permissions](<https://devfeed.tech/tags/file-permissions.md>), [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [policy](<https://devfeed.tech/tags/policy.md>)

### AI overview

Policy is changeable business logic based on explicit business decisions, such as who may use a feature. The article traces commenting access from being available to everyone with file access, to depending on file permissions, and then being restricted for minors in certain jurisdictions. Keeping these checks in multiple platform codebases makes consistent behavior harder as rules accumulate. The author describes centralizing feature access decisions in a testable service: a `decide()` function takes defined inputs and returns a decision, which supports isolated testing and cross-platform code sharing. For server-side policies, Cedar offers a policy language and evaluation specification; its runtime implementations are described as fast, and its definitions can be analyzed for dead paths and conflicts. The article presents centralization and shared definitions as ways to reduce risk and accommodate policy changes.

### Source excerpt

When writing apps, we often talk about "business logic" and treat it like special code. We work hard to isolate our business logic from other parts of the code, like the view layer or framework-specific code, and we say that if you have limited test resources, testing your business logic is the first priority. Business logic is the core behavior of your app, but there's a certain class of business logic that I believe warrants extra attention: Policy.

## ClickHouse release 26.10

DevFeed: [ClickHouse release 26.10](<https://devfeed.tech/articles/clickhouse-release-26-10-121768.md>)

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

Author: ClickHouse

Published: 2026-11-06T11:45:40Z

Content type: release

Language: en

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

Topics: [clickhouse](<https://devfeed.tech/topics/clickhouse.md>), [Release notes](<https://devfeed.tech/topics/release-notes.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [clickhouse](<https://devfeed.tech/tags/clickhouse.md>), [composition](<https://devfeed.tech/tags/composition.md>), [experimental](<https://devfeed.tech/tags/experimental.md>), [faster](<https://devfeed.tech/tags/faster.md>), [flexible](<https://devfeed.tech/tags/flexible.md>), [freeform](<https://devfeed.tech/tags/freeform.md>), [function](<https://devfeed.tech/tags/function.md>), [more](<https://devfeed.tech/tags/more.md>), [release](<https://devfeed.tech/tags/release.md>)

### AI overview

ClickHouse 26.10 adds SQL composition with `|`, quota limits on inserted rows, and new array and map functions. Integer division can optionally truncate toward zero through `sql_compatible_division_for_integers`; that setting is off by default, errors on division by zero, and does not change stored views. Large `IN` subquery sets can spill to disk, enabling the example query to run under a 512 MiB limit with a 128 MiB spill threshold and 203 MiB peak use. Benchmarks report faster grouping by multiple `LowCardinality` columns and about 94% fewer rows read for Top-K grouped queries with dynamic filtering. The experimental columns cache reuses decoded column data (the example's repeated query falls from 32-34 ms to 12 ms); it currently supports wide MergeTree parts. Experimental `LATERAL JOIN` requires enabling a setting. Arbitrary `JOIN` conditions support patterns such as `LIKE`, but may use a block nested loop as slow as a cross join. The release also adds Freeform text input, SQLite input/output formats, and string filtering during scans; the example reports similar time but peak memory falling about 98%.

### Source excerpt

ClickHouse 26.10 introduces function composition, more flexible joins, faster GROUP BY queries, disk spilling for IN subqueries, an experimental columns cache, and Freeform and SQLite formats.

## Composable Parts Architecture

DevFeed: [Composable Parts Architecture](<https://devfeed.tech/articles/composable-parts-architecture-121430.md>)

Original publisher: [Read original article](<https://blog.devops.dev/composable-parts-architecture-b660caf40e8f?source=rss----33f8b2d9a328---4>)

Author: Scaibu

Published: 2026-11-06T09:47:16Z

Content type: article

Language: en

Sources: [DevOps.dev](<https://devfeed.tech/sources/devops-dev.md>)

Topics: [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [architecture-components](<https://devfeed.tech/topics/architecture-components.md>), [Dependency Inversion](<https://devfeed.tech/topics/dependency-inversion.md>), [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>), [adapter pattern](<https://devfeed.tech/topics/adapter-pattern.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>), [event-sourcing](<https://devfeed.tech/topics/event-sourcing.md>), [Deployment Strategies](<https://devfeed.tech/topics/deployment-strategies.md>), [rate-limiting](<https://devfeed.tech/topics/rate-limiting.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [code](<https://devfeed.tech/tags/code.md>), [components](<https://devfeed.tech/tags/components.md>), [connect](<https://devfeed.tech/tags/connect.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [crash](<https://devfeed.tech/tags/crash.md>), [data](<https://devfeed.tech/tags/data.md>), [data-ownership](<https://devfeed.tech/tags/data-ownership.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [design](<https://devfeed.tech/tags/design.md>), [durability](<https://devfeed.tech/tags/durability.md>), [enterprise-architecture](<https://devfeed.tech/tags/enterprise-architecture.md>), [event](<https://devfeed.tech/tags/event.md>), [event-driven-architecture](<https://devfeed.tech/tags/event-driven-architecture.md>), [execution](<https://devfeed.tech/tags/execution.md>), [features](<https://devfeed.tech/tags/features.md>), [independent](<https://devfeed.tech/tags/independent.md>), [integrate](<https://devfeed.tech/tags/integrate.md>), [internals](<https://devfeed.tech/tags/internals.md>), [logic](<https://devfeed.tech/tags/logic.md>), [messages](<https://devfeed.tech/tags/messages.md>), [parts](<https://devfeed.tech/tags/parts.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>)

### AI overview

The architecture aims to let parts change independently by having them depend on published, versioned contracts rather than one another's internals. Each part owns its data and exposes pure logic through ports and replaceable adapters; manifests let the platform validate and wire parts without hand-edited central registries. Events through a durable log are the default connection, while synchronous requests are reserved for cases needing an immediate answer and constrained to short call chains. An atomic outbox, idempotency keys, deduplication, checkpoints, deadlines, and retries make interruptions and duplicate delivery recoverable; consumers keep read-only data copies and reconcile them against their owner. The same contracts and host protocol support different runtimes, with adapters and test kits handling host-specific integration. The excerpt also describes contract versioning, graph validation, and domain-based deployment packing as ways to manage growth. These are architectural prescriptions; the supplied text does not establish implementation results.

### Source excerpt

How small, independent parts connect, share data, survive disconnects, integrate with any host, and grow to 1000+ features -- where adding or changing something touches one place, not a hundred.Contents The six rules Vocabulary The system at a glance Anatomy of a part Contracts Connecting parts Execution model inside a part Data ownership and sharing Integrating with any system Durability: connections that break safely Changing the system Scaling to 1000+ parts Platform components Enforcement Testing Adding a new part: checklist Anti-patterns Open decisions Introduction Most large systems do not fail because a single component is badly written. They fail because components know too much about each other. One service reads another service's tables "just this once"; a handler calls three other services in sequence because it was quicker than designing an event; a central routing file collects one line from every team until nobody can change it without a merge conflict. Each shortcut is harmless on its own. Together they produce a system in which adding a field means editing a hundred files, an outage in one corner takes down everything, and a dropped network connection corrupts data. This document describes a structure that prevents those outcomes by design rather than by discipline. It rests on two ideas: No part knows another part. Parts know contracts. A part is aware of its own logic and of the published, versioned contracts it uses. It never sees another part's code, storage, or deployment details. Because nothing depends on internals, internals can change freely. Every connection is assumed to break, and breaking must cost nothing. Networks drop, processes crash, and messages arrive twice or out of order. Instead of trying to prevent these failures, the structure makes each one harmless: nothing is lost, nothing happens twice, and nothing waits forever. Everything that follows is an elaboration of those two ideas, together with the tooling that keeps them true as

## A database is a store for global variables

DevFeed: [A database is a store for global variables](<https://devfeed.tech/articles/a-database-is-a-store-for-global-variables-121312.md>)

Original publisher: [Read original article](<https://seangoedecke.com/a-database-is-a-store-for-global-variables/>)

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

Content type: opinion

Language: en

Sources: [Sean Goedecke](<https://devfeed.tech/sources/seangoedecke-com-rss-feed.md>)

Topics: [Database](<https://devfeed.tech/topics/database.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [advice](<https://devfeed.tech/tags/advice.md>), [apps](<https://devfeed.tech/tags/apps.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [code](<https://devfeed.tech/tags/code.md>), [column](<https://devfeed.tech/tags/column.md>), [data](<https://devfeed.tech/tags/data.md>), [database](<https://devfeed.tech/tags/database.md>), [databases](<https://devfeed.tech/tags/databases.md>), [function](<https://devfeed.tech/tags/function.md>), [global](<https://devfeed.tech/tags/global.md>), [program](<https://devfeed.tech/tags/program.md>), [programming](<https://devfeed.tech/tags/programming.md>), [query](<https://devfeed.tech/tags/query.md>), [records](<https://devfeed.tech/tags/records.md>), [software](<https://devfeed.tech/tags/software.md>), [state](<https://devfeed.tech/tags/state.md>), [store](<https://devfeed.tech/tags/store.md>), [systems](<https://devfeed.tech/tags/systems.md>), [value](<https://devfeed.tech/tags/value.md>), [variables](<https://devfeed.tech/tags/variables.md>)

### AI overview

The excerpt argues that databases behave like global variables: any program component can query or change shared state, creating implicit data flow and coupling. It considers five explanations for why database-backed programs can still be better structured: they may simply be messier; ACID guarantees may reduce harm; database access is more explicit; databases store less flexible values; and established conventions limit their use. The author is unconvinced by ACID guarantees and flexibility as the main explanations, and favors explicit query points and norms such as checking column types and reserving databases for suitable uses. These advantages are contingent on how a codebase uses its tools, so the author treats both "avoid globals" and "use a database for state" as heuristics that need concrete reasons.

### Source excerpt

Databases are for storing global variables. We usually call them "rows" or "records" instead, but they're definitionally global variables: any part of your program can read or write them. Isn't this kind of weird? It's common programming advice that global variables are bad, and yet many elegant programs rely on databases. Either the common advice is wrong, or there's something special about databases that makes them the exception to the rule. What's so bad about global variables? Here's the two main1 reasons, in my view: They allow any part of your program to implicitly send data to any other part instead of passing it around via function signatures They couple different parts of your program: if one part depends on a variable having some value, any other part can break it Both of these apply to databases. Any part of your program that makes a query can send and receive data from any other part of your program. In practice this happens all the time: one function will save some data on a record, and another one will check for it. And if you haven't seen bugs where some piece of code makes some incorrect expectation about the shape2 of a database column, you haven't been working on web systems for long enough. So why aren't database-backed apps in terrible architectural shape? In the rest of this post I'll consider some options. First, we could bite the bullet: maybe all database-backed apps really are a mess. This is surprisingly plausible. When I think about the systems I've worked on that haven't involved a database, they're usually much cleaner and more elegant. If managing state is the hardest thing about designing software -- and I think it is -- then systems that manage less state are going to be better-designed. However, this doesn't explain everything. Database-backed apps aren't that bad, and even in database-backed apps, we try to avoid introducing regular global variables3, so in practice we treat global variables as worse. Second, we could say that databas

## How to Fix React State Updates with Immutable Data

DevFeed: [How to Fix React State Updates with Immutable Data](<https://devfeed.tech/articles/how-to-fix-react-state-updates-with-immutable-data-119684.md>)

Original publisher: [Read original article](<https://jsdev.space/howto/react-immutable-state/>)

Author: anton liberant

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

Content type: tutorial

Language: en

Sources: [JavaScript Development](<https://devfeed.tech/sources/javascript-development.md>)

Topics: [React](<https://devfeed.tech/topics/react.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [state-management](<https://devfeed.tech/topics/state-management.md>)

Tags: [arrays](<https://devfeed.tech/tags/arrays.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [immutable-data](<https://devfeed.tech/tags/immutable-data.md>), [nested-objects](<https://devfeed.tech/tags/nested-objects.md>), [react](<https://devfeed.tech/tags/react.md>), [react-memo](<https://devfeed.tech/tags/react-memo.md>), [reference](<https://devfeed.tech/tags/reference.md>), [rendering](<https://devfeed.tech/tags/rendering.md>), [state](<https://devfeed.tech/tags/state.md>), [ui](<https://devfeed.tech/tags/ui.md>), [updates](<https://devfeed.tech/tags/updates.md>)

### AI overview

React state updates depend on value identity: mutating an existing array or object and passing back the same reference can leave the UI or memoized calculations stale. Use functional state updaters to derive the next value from current state, creating new references only along the changed path. For arrays, the article demonstrates spread syntax, `filter()`, `map()`, and copying before `sort()`; `toSorted()` is another option when the JavaScript environment supports it. For nested objects, copy each level on the path being changed and preserve unchanged branches. `React.memo` and `useMemo` rely on stable, meaningful references, so unnecessary new objects can also defeat memoization. For complex nested updates, Immer and `use-immer` allow mutation-like draft code while producing immutable results. Preserving snapshots also enables undo and redo, though the example history hook assumes callers do not mutate stored values and recommends grouping edits or limiting history for production use.

### Source excerpt

Learn why React state mutations cause stale UI, how reference equality affects rendering, and how to update arrays and nested objects safely.

## CoGSeq-LTV: Scalable Missing-Aware Graph-Sequence Modeling for Multi-Business Transaction Analytics

DevFeed: [CoGSeq-LTV: Scalable Missing-Aware Graph-Sequence Modeling for Multi-Business Transaction Analytics](<https://devfeed.tech/articles/cogseq-ltv-scalable-missing-aware-graph-sequence-modeling-for-multi-business-transaction-analytics-115218.md>)

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

Author: Ziyang Su, Yao Zhou, Kelin Liu, Guanjie Zheng, Linghe Kong

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

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Graph Mining](<https://devfeed.tech/topics/graph-mining.md>), [product analytics](<https://devfeed.tech/topics/product-analytics.md>)

Tags: [alignment](<https://devfeed.tech/tags/alignment.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [batch](<https://devfeed.tech/tags/batch.md>), [business](<https://devfeed.tech/tags/business.md>), [context](<https://devfeed.tech/tags/context.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [data](<https://devfeed.tech/tags/data.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [future](<https://devfeed.tech/tags/future.md>), [global](<https://devfeed.tech/tags/global.md>), [graph](<https://devfeed.tech/tags/graph.md>), [handle](<https://devfeed.tech/tags/handle.md>), [handling](<https://devfeed.tech/tags/handling.md>), [horizon](<https://devfeed.tech/tags/horizon.md>), [large](<https://devfeed.tech/tags/large.md>), [logs](<https://devfeed.tech/tags/logs.md>), [modeling](<https://devfeed.tech/tags/modeling.md>), [sequence](<https://devfeed.tech/tags/sequence.md>), [transaction](<https://devfeed.tech/tags/transaction.md>), [transaction-analytics](<https://devfeed.tech/tags/transaction-analytics.md>)

### AI overview

CoGSeq-LTV combines a batch-induced user-item graph, business-aware transaction sequence encoders, and cross-view contrastive alignment to predict customer value across businesses and time horizons. Reserved unknown-item handling accommodates missing item identifiers, while the sequence encoders retain recency, event gaps, payment context, and goods-table availability. For sparse, zero-inflated, heavy-tailed cumulative targets, it uses a zero-inflated mixture log-normal output with MAE-aligned point supervision and validation-calibrated zero-aware inference. On the BiBiSheng dataset, the authors report improvements over representative LTV baselines across businesses and horizons, including in a later out-of-time evaluation window; the excerpt provides no metric details.

### Source excerpt

arXiv:2611.01817v1 Announce Type: new Abstract: Large-scale super-apps generate heterogeneous transaction logs in which users interact with multiple businesses, item identifiers are only partially available, and future value targets are sparse, heavy-tailed, and cumulative over time. We study multi-business, multi-horizon value prediction as a data-intensive analytics problem over such logs, rather than as a single-table task. (i) a batch-induced user-item graph that provides collaborative signals without materializing a global graph and remains applicable when item identifiers are missing through reserved unknown-item handling, (ii) business-aware sequence encoders that preserve recency, inter-event gaps, payment context, and goods-table availability, and (iii) cross-view contrastive alignment that transfers user-level intent across businesses while retaining business-specific temporal patterns. To handle zero-inflated and long-tailed cumulative targets, CoGSeq-LTV adopts a zero-inflated mixture log-normal head with MAE-aligned point supervision and validation-calibrated zero-aware inference. Experiments on the BiBiSheng transaction-log dataset show that CoGSeq-LTV improves over representative LTV baselines across businesses and horizons, including under a later out-of-time evaluation window.

## FAOPs: Normal Forms and an Algebra for AI Agent Workflows

DevFeed: [FAOPs: Normal Forms and an Algebra for AI Agent Workflows](<https://devfeed.tech/articles/faops-normal-forms-and-an-algebra-for-ai-agent-workflows-113637.md>)

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

Author: Ali Mohammadi Shanghooshabad (JPMorgan Chase,Co.)

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

Content type: article

Language: en

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

Topics: [Multi-step AI processes](<https://devfeed.tech/topics/multi-step-ai-processes.md>), [Agent Skills](<https://devfeed.tech/topics/agent-skills.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [ai security](<https://devfeed.tech/topics/ai-security.md>), [Advanced AI workflows](<https://devfeed.tech/topics/advanced-ai-workflows.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-skills](<https://devfeed.tech/tags/agent-skills.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>), [algebra](<https://devfeed.tech/tags/algebra.md>), [compile](<https://devfeed.tech/tags/compile.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [completion](<https://devfeed.tech/tags/completion.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [database](<https://devfeed.tech/tags/database.md>), [executor](<https://devfeed.tech/tags/executor.md>), [functional](<https://devfeed.tech/tags/functional.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [library](<https://devfeed.tech/tags/library.md>), [limits](<https://devfeed.tech/tags/limits.md>), [management](<https://devfeed.tech/tags/management.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

FAOP formalizes AI agent workflows as typed functions over scoped state and applies four library-wide normal forms: decomposing work into atomic steps, making data flow explicit and type-checked, centralizing shared sub-workflows, and checking resource and guardrail scope. Its algebra defines sound refactoring and parallelization rewrites; extensions cover optimization, time and cost bounds, and reachability checks, while a classifier assesses whether a workflow needs AI. The authors implement FAOP in SkillBase and a separate executor that enforces the stated guarantees at runtime. The supplied abstract also mentions an end-to-end financial workflow example.

### Source excerpt

arXiv:2610.22061v2 Announce Type: replace-cross Abstract: Organizations increasingly encode operational procedures as multi-step agent skills, here called Agent Operating Procedures (AOPs), that must be traceable, auditable, reproducible, access-controlled, and bounded in time and cost, as regulated sectors require. Yet AOPs are typically kept as coarse-grained files, in which steps bundle actions, copied procedures drift apart, any step may reach any tool, and refactoring goes unchecked. We present Functional Agent Operating Procedures (FAOP), a formal theory that brings database-grade discipline to AI agent workflows. FAOP recasts each workflow as a typed function over scoped state and subjects an entire library to four progressive normal forms: Decomposed (FNF-1) splits a workflow into atomic steps, Typed (FNF-2) makes its data flow explicit and type-checked, Factored (FNF-3) gives each shared sub-workflow a single canonical definition so a change propagates instead of drifting, and Scoped (FNF-4) checks that each FAOP lists resources used by its own actions and the FAOPs it calls, while guardrails declared by it and by FAOPs that call it remain attached to their sources. A FAOP algebra of provably sound equalities turns refactoring and parallelization into compiler rewrites; orthogonal extensions add optimization (+O), bounded completion with time and cost limits (+B), and reachability checks (+R); and an architectural-level classifier (0-3) determines whether a workflow needs AI at all. Together, these make integrity, isolation, typing, stopping limits, cost, and optimization compile-time concerns across the whole library, not runtime hopes. We implement the theory in SkillBase, an AOP management system (what PostgreSQL is to data, SkillBase is to AOPs), and a separate executor that loads FAOPs from SkillBase and enforces these guarantees at run time. A worked financial workflow illustrates the approach end to end.

## Kotlin Flow Debugging: Trace combine and flatMapLatest with onEach

DevFeed: [Kotlin Flow Debugging: Trace combine and flatMapLatest with onEach](<https://devfeed.tech/articles/kotlin-flow-debugging-trace-combine-and-flatmaplatest-with-oneach-105767.md>)

Original publisher: [Read original article](<https://proandroiddev.com/kotlin-flow-debugging-trace-combine-and-flatmaplatest-with-oneach-863b337f945f?source=rss----c72404660798---4>)

Author: chanzmao

Published: 2026-10-29T01:59:28Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [coroutines-flow](<https://devfeed.tech/topics/coroutines-flow.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [flow](<https://devfeed.tech/tags/flow.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [logging](<https://devfeed.tech/tags/logging.md>)

### AI overview

Kotlin Flow's `onEach` operator lets you log each emitted value without changing it, but its action runs only when the Flow is collected. Place it on inputs to `combine` and around pipeline operators to see emissions, recomputations, and where values are filtered or transformed. With `flatMapLatest`, log the outer queries and inner results separately; use `onCompletion` to inspect a prior inner Flow's completion cause when a new query cancels it. These logs help reveal behavior, but close or concurrent emissions do not guarantee a one-to-one causal order with `combine` calls. For exact correlation, the excerpt recommends explicit event identifiers or separately modeled trigger events. Emission logs also do not show internal work such as when a network request starts or the server responds; log at the repository or network boundary for that.

### Source excerpt

Inspect emissions, find unexpected recomputations, and debug Flow pipelines with minimal code. Image created by AIWhere Did This Emission Come From? Kotlin Flow makes it easy to build declarative data pipelines. We can combine multiple streams with combine, switch between upstream flows with flatMapLatest, and transform values with operators such as map and filter. But as a pipeline grows, debugging becomes surprisingly difficult. Imagine a ViewModel that combines repository data, a search query, and a UI preference: val uiState = combine( repository.items, searchQuery, showAds, ) { items, query, showAds -> createUiState(items, query, showAds) } When createUiState() runs, which input triggered it? Did the repository emit new items? Did the user change the search query? Did the ad preference change? Or did several inputs emit values in quick succession? The combine lambda receives the latest value from every upstream Flow, but it doesn't tell us which Flow emitted most recently. We could introduce wrapper classes, restructure the pipeline, or add logging throughout the codebase. However, for everyday debugging, there is a much simpler solution: onEach. It lets us inspect values as they pass through a Flow without transforming them or changing the pipeline's data model. Let's see how to use it effectively. Why onEach Is the Easiest Way to Inspect a Flow The onEach operator performs an action for every emitted value before passing that value downstream. flow .onEach { value -> println("Emitted: $value") } .map { value -> transform(value) } The important point is that onEach doesn't transform the emitted value. This makes onEach ideal for temporary diagnostic logging. We can insert it into an existing pipeline, inspect what's happening, and remove it when we're done. There is one important detail: Flow is generally lazy. Adding onEach doesn't start collection by itself. Its action runs only when the Flow is collected and an upstream value is emitted. Identify Which Flow

## On the Expressiveness of Asynchronous Processes with Nested Session Types

DevFeed: [On the Expressiveness of Asynchronous Processes with Nested Session Types](<https://devfeed.tech/articles/on-the-expressiveness-of-asynchronous-processes-with-nested-session-types-100169.md>)

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

Author: Sjors Wortelboer, Dan Frumin, Jorge A. P\\'erez

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

Content type: article

Language: en

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

Topics: [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [nested](<https://devfeed.tech/tags/nested.md>), [processes](<https://devfeed.tech/tags/processes.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>)

### AI overview

The paper shows that Asynchronous Session Processes (ASP), the process model associated with Nested Session Types (NSTs), can encode two-counter machines in typed processes, establishing Turing completeness. The encoding uses a state-aware representation of counters and instructions governed by NSTs. The abstract contrasts this result with NSTs' known characterization by one-counter machines and deterministic context-free languages.

### Source excerpt

arXiv:2610.32558v1 Announce Type: cross Abstract: Session types are a type-based approach to correct message-passing programs, where types specify protocols for channels and type checking guarantees communication correctness. Traditional session types express regular protocols only, which leaves out many protocols found in practice. Aiming at overcoming this limitation, Nested Session Types (NSTs) can specify nested recursive protocols. NSTs are known to be characterised by one-counter machines and deterministic context-free languages. In this paper, we study the expressiveness of ASP (Asynchronous Session Processes), the process model associated with NSTs as introduced by Das et al. We prove that AST is Turing complete by giving a correct encoding of two-counter machines into typed processes. Our encoding uses a non-trivial state-aware representation of counters and instructions that is neatly governed by NSTs.

## My Tests Fail If Anyone Types a Dollar Amount by Hand

DevFeed: [My Tests Fail If Anyone Types a Dollar Amount by Hand](<https://devfeed.tech/articles/my-tests-fail-if-anyone-types-a-dollar-amount-by-hand-99290.md>)

Original publisher: [Read original article](<https://hackernoon.com/my-tests-fail-if-anyone-types-a-dollar-amount-by-hand?source=rss>)

Author: horushe

Published: 2026-10-25T17:00:02Z

Content type: tutorial

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [Test automation](<https://devfeed.tech/topics/test-automation.md>), [MDX](<https://devfeed.tech/topics/mdx.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [accessible](<https://devfeed.tech/tags/accessible.md>), [alt-text](<https://devfeed.tech/tags/alt-text.md>), [astro](<https://devfeed.tech/tags/astro.md>), [bug](<https://devfeed.tech/tags/bug.md>), [build](<https://devfeed.tech/tags/build.md>), [calculator](<https://devfeed.tech/tags/calculator.md>), [charts](<https://devfeed.tech/tags/charts.md>), [components](<https://devfeed.tech/tags/components.md>), [concrete](<https://devfeed.tech/tags/concrete.md>), [cost](<https://devfeed.tech/tags/cost.md>), [data](<https://devfeed.tech/tags/data.md>), [data-visualization](<https://devfeed.tech/tags/data-visualization.md>), [fail](<https://devfeed.tech/tags/fail.md>), [function](<https://devfeed.tech/tags/function.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [mdx](<https://devfeed.tech/tags/mdx.md>), [number](<https://devfeed.tech/tags/number.md>), [prices](<https://devfeed.tech/tags/prices.md>), [programming](<https://devfeed.tech/tags/programming.md>), [static-site-generator](<https://devfeed.tech/tags/static-site-generator.md>), [svg](<https://devfeed.tech/tags/svg.md>), [testing](<https://devfeed.tech/tags/testing.md>), [tests](<https://devfeed.tech/tags/tests.md>), [time](<https://devfeed.tech/tags/time.md>), [web-development](<https://devfeed.tech/tags/web-development.md>)

### AI overview

The author prevents stale prices in Astro articles by testing every guide MDX file for a dollar sign followed by a digit, including drafts; separate checks ensure calculator pages are covered. Inline components render computed figures, while one pure function supplies the table, build time SVG chart, and chart description. Tests also verify that stated trends in the prose still match the data after refreshes. Supplier prices that cannot be computed are kept in a single source documented data file, though the test cannot verify transcription accuracy. The rule is enforced only when Vitest is run: the build does not run it, and the project has no CI. Its regex misses spelled out amounts, currency codes, and typed percentages, while untested prose claims can still become outdated.

### Source excerpt

A one-line Vitest rule bans hand-typed prices in MDX; components and build-time SVG charts pull every number from one function.

## Everything Is a Source -- Part 1

DevFeed: [Everything Is a Source -- Part 1](<https://devfeed.tech/articles/everything-is-a-source-part-1-88050.md>)

Original publisher: [Read original article](<https://proandroiddev.com/everything-is-a-source-part-1-0155cfd84c4d?source=rss----c72404660798---4>)

Author: Damian Petla | Tilt

Published: 2026-10-15T16:42:03Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [coroutines-flow](<https://devfeed.tech/topics/coroutines-flow.md>), [business logic](<https://devfeed.tech/topics/business-logic.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Grafana](<https://devfeed.tech/topics/grafana.md>), [OpenTelemetry](<https://devfeed.tech/topics/opentelemetry.md>)

Tags: [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [android](<https://devfeed.tech/tags/android.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [business-logic](<https://devfeed.tech/tags/business-logic.md>), [caching](<https://devfeed.tech/tags/caching.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [error-handling](<https://devfeed.tech/tags/error-handling.md>), [flow](<https://devfeed.tech/tags/flow.md>), [framework](<https://devfeed.tech/tags/framework.md>), [ios](<https://devfeed.tech/tags/ios.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-coroutines](<https://devfeed.tech/tags/kotlin-coroutines.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [networking](<https://devfeed.tech/tags/networking.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [repository](<https://devfeed.tech/tags/repository.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>)

### AI overview

Tilt replaced hand-written coroutine plumbing and 11 Apollo-specific combine overloads with a roughly 1,600-line Kotlin pipeline built around `PipelineSource<T>`, which wraps `Flow<TiltResult<T>>`. A single `source(...)` factory accepts Apollo calls, flows, values, or existing results; typed combine functions short-circuit on failure, and `build()` and `buildOnce()` distinguish long-lived streams from one-shot reads. Failures propagate by default, while explicit fallbacks make deliberate degradation visible; the home-feed example logs, times out, and falls back for optional settings while allowing feed failures through. The framework also exposed a migration tradeoff: replacing an auction product cache with a stream suppressed unrelated auction updates and refetched all products when IDs changed, so the author restored a plain cache that hands out sources. The excerpt says the shared module has over 50 files using the pattern and that older code is migrating function by function. Its closing section describes tracing as planned for Part 2, not covered here.

### Source excerpt

Part 1 of 2: how a small, home-grown data pipeline became the backbone of Tilt's Kotlin Multiplatform data layer. Part 2 covers what it unlocked: OpenTelemetry tracing with Grafana. At Tilt, the Android and iOS apps share one Kotlin Multiplatform module that owns networking, caching and business logic. A year ago, every repository function in it was a small, hand-rolled piece of coroutine plumbing. Today almost every new one is a single expression that reads like a sentence: source(apolloClient.query(ProductQuery(id))) .transform { converter.toDomain(it) } .buildOnce() This article is about the roughly 1,600 lines of Kotlin behind that expression: why I built them instead of adopting a library, the first design I threw away, and the one idea that survived every refactor: everything is a source. There is also a twist I did not plan for. I built the framework as guardrails for developers who did not know Flows well. It turned out to be exactly the guardrails AI coding agents needed too. The problem: more contributors, less Flow experience In late 2025, iOS developers started contributing to the shared module. That was the point of Kotlin Multiplatform, and it was great. But coroutines and Flows have plenty of sharp edges: when a flow completes, what flatMapLatest cancels, where an exception ends up, why you must never swallow a CancellationException. These are not obvious if Swift is your daily language. The bigger issue was not knowledge of Flows. It was error handling that was quietly skipped. A typical repository function looked like this: return flow { emit(executeDataCatching(apolloClient.query(BundlesConfigQuery(roomId))) { /* map */ }) }.flatMapLatest { configResult -> if (configResult.isSuccess) { val config = configResult.getOrThrow() if (config.sellerId != null && config.enabled) { combineTiltResult( apolloClient.subscription(BundlesSubscription(config.sellerId)), apolloClient.subscription(AddressSubscription(roomId)), ) { bundles, address -> converter.toDom

## I Want More from AI Than Another Agent | matgreten.dev

DevFeed: [I Want More from AI Than Another Agent | matgreten.dev](<https://devfeed.tech/articles/i-want-more-from-ai-than-another-agent-matgreten-dev-86866.md>)

Original publisher: [Read original article](<https://swamp-club.com/feed/p/986de6de-bbfd-4e70-839b-f21c4202c08a/go>)

Author: mgreten

Published: 2026-10-14T15:35:34Z

Content type: opinion

Language: en

Sources: [Swamp Club Feed](<https://devfeed.tech/sources/swamp-club-feed.md>)

Topics: [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [AI Integration Strategies](<https://devfeed.tech/topics/ai-integration-strategies.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [operations](<https://devfeed.tech/tags/operations.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

The author argues that reusable, behavior-centric operations reduce repeated AI orchestration: define typed methods with validated inputs and outputs, then compose them into workflows that control sequence, conditions, and failure handling. In Swamp, workflows can call models for bounded tasks such as assessing PR comments, while code handles settled mechanics such as polling, running checks, and recording results; posting replies or applying changes remains a separate action. The author says this makes procedures easier to inspect and reuse across projects, but does not eliminate API failures, stale assumptions, model errors, or human responsibility. They also describe scaling back excessive checks: code can validate required fields, while judging whether a plan makes sense remains a human decision.

### Source excerpt

A developer argues for behavior-centric design over agent-centric workflows, advocating for reusable, typed operations with defined inputs and outputs that constrain when AI reasoning is invoked rather than letting models orchestrate entire processes.

## Three Samplers, One Posterior: NUTS vs. Emcee vs. Nested Sampling

DevFeed: [Three Samplers, One Posterior: NUTS vs. Emcee vs. Nested Sampling](<https://devfeed.tech/articles/three-samplers-one-posterior-nuts-vs-emcee-vs-nested-sampling-86096.md>)

Original publisher: [Read original article](<https://towardsdatascience.com/three-samplers-one-posterior-nuts-vs-emcee-vs-nested-sampling/>)

Author: Samit Ganguly

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

Content type: comparison

Language: en

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

Topics: [Ground truth / benchmark quality](<https://devfeed.tech/topics/ground-truth-benchmark-quality.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [astrophysics](<https://devfeed.tech/tags/astrophysics.md>), [bayesian](<https://devfeed.tech/tags/bayesian.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [data-sciecne](<https://devfeed.tech/tags/data-sciecne.md>), [hamiltonian-monte-carlo](<https://devfeed.tech/tags/hamiltonian-monte-carlo.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [sampling](<https://devfeed.tech/tags/sampling.md>), [statistics](<https://devfeed.tech/tags/statistics.md>)

### AI overview

The article benchmarks NUTS, emcee, and dynesty against exact reference results on three Bayesian sampling problems. NUTS is fastest on smooth problems but gets stuck among modes; emcee can assign confidently incorrect weights to modes; dynesty finds the modes and estimates evidence, though its reported uncertainty can be too small. It recommends choosing a sampler based on the posterior's shape and whether model evidence is needed, and checking convergence against problems with known answers.

### Source excerpt

Benchmarking NumPyro, affine-invariant MCMC, and dynesty against exact ground truth and watching them fail. The post Three Samplers, One Posterior: NUTS vs. Emcee vs. Nested Sampling appeared first on Towards Data Science.

## Flex Model: an event-driven feature engineering system

DevFeed: [Flex Model: an event-driven feature engineering system](<https://devfeed.tech/articles/flex-model-an-event-driven-feature-engineering-system-88874.md>)

Original publisher: [Read original article](<https://blog.janestreet.com/flex-model-an-event-driven-feature-engineering-system/>)

Author: Stanislaw Maczka

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

Content type: article

Language: en

Sources: [Jane Street](<https://devfeed.tech/sources/jane-street.md>)

Topics: [Feature Engineering](<https://devfeed.tech/topics/feature-engineering.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [event driven](<https://devfeed.tech/topics/event-driven.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [engineering](<https://devfeed.tech/tags/engineering.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [feature](<https://devfeed.tech/tags/feature.md>), [feature-engineering](<https://devfeed.tech/tags/feature-engineering.md>)

### AI overview

Jane Street describes Flex Model, an event-driven feature engineering framework that converts market events into numerical features for trading systems. The article explains its stateful feature model, a planner that schedules handlers and evaluations for different event types, and performance work including preallocated memory and OxCaml unboxed floats. The system aims to let researchers compose reusable features while limiting unnecessary computation across markets.

### Source excerpt

Neural networks are a tool we use heavily in many trading strategies. But raw market data can't be fed to a neural net as-is. It's an unstructured input that needs normalization and feature extraction first.

## Functional Programming in Python: When and How to Use It

DevFeed: [Functional Programming in Python: When and How to Use It](<https://devfeed.tech/articles/functional-programming-in-python-when-and-how-to-use-it-84689.md>)

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

Author: John Sturtz

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

Content type: tutorial

Language: en

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

Topics: [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Python](<https://devfeed.tech/topics/python.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

This tutorial explains how Python supports functional programming through first-class functions and anonymous functions with lambda. It demonstrates using map(), filter(), and reduce(), and discusses when these tools are useful alongside more Pythonic alternatives such as comprehensions.

### Source excerpt

See how Python supports functional programming, what the paradigm actually is, and where it fits in the code you write day to day.

## EveryThing You Need To Know About Scala

DevFeed: [EveryThing You Need To Know About Scala](<https://devfeed.tech/articles/everything-you-need-to-know-about-scala-65415.md>)

Original publisher: [Read original article](<https://blog.devops.dev/everything-you-need-to-know-about-scala-c833fe885c44?source=rss----33f8b2d9a328---4>)

Author: Rahul Patidar

Published: 2026-10-06T13:04:28Z

Content type: article

Language: en

Sources: [DevOps.dev](<https://devfeed.tech/sources/devops-dev.md>)

Topics: [Scala](<https://devfeed.tech/topics/scala.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [class](<https://devfeed.tech/topics/class.md>), [Closure](<https://devfeed.tech/topics/closure.md>), [constructor](<https://devfeed.tech/topics/constructor.md>), [Exception](<https://devfeed.tech/topics/exception.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [superclass](<https://devfeed.tech/topics/superclass.md>)

Tags: [app](<https://devfeed.tech/tags/app.md>), [block](<https://devfeed.tech/tags/block.md>), [class](<https://devfeed.tech/tags/class.md>), [classes](<https://devfeed.tech/tags/classes.md>), [closure](<https://devfeed.tech/tags/closure.md>), [design-patterns](<https://devfeed.tech/tags/design-patterns.md>), [exception](<https://devfeed.tech/tags/exception.md>), [exception-handling](<https://devfeed.tech/tags/exception-handling.md>), [factory](<https://devfeed.tech/tags/factory.md>), [frameworks](<https://devfeed.tech/tags/frameworks.md>), [function](<https://devfeed.tech/tags/function.md>), [functions](<https://devfeed.tech/tags/functions.md>), [monad](<https://devfeed.tech/tags/monad.md>), [none](<https://devfeed.tech/tags/none.md>), [nothing](<https://devfeed.tech/tags/nothing.md>), [null](<https://devfeed.tech/tags/null.md>), [packages](<https://devfeed.tech/tags/packages.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [scala](<https://devfeed.tech/tags/scala.md>), [syntax](<https://devfeed.tech/tags/syntax.md>)

### AI overview

The excerpt presents Scala interview topics through short explanations and code examples. It describes factory, singleton, and lazy initialization patterns; treating functions as values and higher-order functions; tail recursion, closures, placeholder syntax, partially applied functions, currying, purity, and anonymous functions. It also covers trait linearization in the diamond problem, monads, case class features, primary and auxiliary constructors, named Scala frameworks, exception handling without checked exceptions, BitSet, the App helper, package names, and Null, Nil, None, and Nothing. The supplied text ends mid-example in the factory pattern and is therefore an excerpt rather than evidence of the complete article.

### Source excerpt

Everyone who is a beginner in scala faces many problems and has many confusions while trying to understand important concepts in scala. In interviews, interviewers frequently ask about these concepts in Scala, and candidates are frequently unable to impress or explain these concepts to interviewers. So in today's post, I will be covering some important concepts in Scala, so whenever you go for your next interview, just read these concepts once and it will really help you to answer Scala Related Interview Questions. This post will cover the following topics: 1. Scala Design Patterns 2. First Class function 3. Higher-Order Functions 4. Tail Recursion in Scala. 5. Block of Code. 6. Closure 7. PlaceHolder Syntax: 8. Partially Applied Function: 9. Function Currying : 10. pure functions : 11. Anonymous Function: 12. Diamond Problem In scala: 13. traint in scala: 14. Monad in scala: 15. Case Classes In Scala. 16. constructors in Scala 17. Frameworks supported by Scala 18. Exception Handling in Scala 19. BitSet 20. app Class 21. Packages in Scala 22. Null, Nill, None, and Nothing in Scala Scala Design Patterns. Every time you develop some software, there are some common problems that everyone faces in his/her software engineering journey. To resolve these issues, we have some predefined general-purpose reusable solutions. These reusable solutions are nothing but design patterns. These are the types of templates that we can use as a solution whenever we encounter these issues. We have 3 kinds of design patterns in Scala. The factory design pattern: the main aim of the factory design pattern is to separate instance creation logic from the client. Here we implement instance creation logic in the factory class without exposing this logic to the client. It is used when we have multiple subclasses with one superclass and, based on the input, we need to return one of the inputs. Example trait Computer { def ram: String def hdd: String def cpu: String } case class PC(ram: String, h

[Next page](<https://devfeed.tech/topics/functional-programming.md?cursor=WyIyMDI2LTEwLTA2VDEzOjA0OjI4KzAwOjAwIiwgImEzZTEyN2JhLTg1N2UtNGY3MC1hODcyLTU4ZmU1YTEzMGM4MiJd>)