# typesafety

Type safety is the property of a programming language or program that prevents or discourages type errors and certain mismatches during execution.

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

## Type-Confusion Security

DevFeed: [Type-Confusion Security](<https://devfeed.tech/articles/type-confusion-security-139297.md>)

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

Author: Silei Ren, Hanxi Chen, Suraaj Kanniwadi, Andrew C. Myers

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

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [typesafety](<https://devfeed.tech/topics/typesafety.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [Security](<https://devfeed.tech/topics/security.md>)

Tags: [attack](<https://devfeed.tech/tags/attack.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [lean](<https://devfeed.tech/tags/lean.md>), [model-context-protocol](<https://devfeed.tech/tags/model-context-protocol.md>), [security](<https://devfeed.tech/tags/security.md>), [type](<https://devfeed.tech/tags/type.md>), [type-system](<https://devfeed.tech/tags/type-system.md>)

### AI overview

The paper defines type-confusion security as ensuring that attackers who ignore a type system gain no more power than attackers who obey it. It treats attacks such as confused deputies, reentrancy, and control-flow hijacking as instances of type confusion. In an information-flow-typed core calculus, the authors formalize the property as a real-ideal emulation and prove that runtime checks preserve the security guarantees of the type system even against ill-typed attackers. They mechanize the proof in Lean.

### Source excerpt

arXiv:2611.20298v1 Announce Type: cross Abstract: Type systems are a lightweight way to obtain formal assurance that code upholds security properties. However, decentralized systems, such as smart contracts and Model Context Protocol ecosystems, have limited ability to constrain the behavior of untrusted code. In such systems, attackers may attempt to confuse trusted code by supplying values that do not behave according to their advertised types, an attack that we call type confusion. Well-known attacks such as confused deputy attacks, reentrancy attacks, and control-flow hijacking can be understood as instances of type confusion. We define type confusion security as the property that unrestricted attackers who need not follow the type system have no more power than limited attackers who fully obey it. We formally define type confusion security as a real--ideal emulation, and in the context of an information-flow-typed core calculus that statically enforces security against well-typed attackers, prove that its run-time checks also enforce security against ill-typed attackers. In this system, programmers can write code while reasoning about security only against well-typed attackers; the security guarantees enforced by the type system still hold. We mechanize a proof of type confusion security in Lean.

## Precision in type system design (or the Option type as an anti-pattern)

DevFeed: [Precision in type system design (or the Option type as an anti-pattern)](<https://devfeed.tech/articles/precision-in-type-system-design-or-the-option-type-as-an-anti-pattern-139422.md>)

Original publisher: [Read original article](<https://dashbit.co/blog/precision-in-type-system-design>)

Author: José Valim

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

Content type: article

Language: en

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

Topics: [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [union types](<https://devfeed.tech/topics/union-types.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [api](<https://devfeed.tech/tags/api.md>), [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [array](<https://devfeed.tech/tags/array.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [article](<https://devfeed.tech/tags/article.md>), [binaries](<https://devfeed.tech/tags/binaries.md>), [boolean](<https://devfeed.tech/tags/boolean.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [code](<https://devfeed.tech/tags/code.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [collection](<https://devfeed.tech/tags/collection.md>), [design](<https://devfeed.tech/tags/design.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [option](<https://devfeed.tech/tags/option.md>), [precision](<https://devfeed.tech/tags/precision.md>), [simplicity](<https://devfeed.tech/tags/simplicity.md>), [type](<https://devfeed.tech/tags/type.md>), [type-system](<https://devfeed.tech/tags/type-system.md>)

### AI overview

The article argues that greater type precision can expose hidden runtime assumptions, while also making programs harder to prove, signatures more verbose, error messages harder to read, and type checking slower. Its Elixir examples show how distinguishing empty from non-empty lists lets `Enum.max_by` require a non-empty list and catches an unsafe refactor; however, proving that a list remains non-empty after dropping elements can still exceed the type system's capabilities. The author calls `Option`/`Maybe` results an anti-pattern for API and language designers when they compensate for behavior that could be guaranteed statically, while recognizing they remain appropriate for inherently uncertain operations such as file access. Types rule out some errors but do not make programs error-free, so runtime failures still need isolation. The article concludes that sound, decidable type systems will reject some valid programs, and that designers must balance precision with ergonomics and performance.

### Source excerpt

When fine-tuning a type system for precision, we often have to make trade-offs between simplicity and expressiveness in its design. The goal of this article is to explore these trade-offs.

## true or false in CSS

DevFeed: [true or false in CSS](<https://devfeed.tech/articles/true-or-false-in-css-121945.md>)

Original publisher: [Read original article](<https://blog.master.dev/true-or-false-in-css/>)

Author: Preethi Sam

Published: 2026-11-06T13:38:19Z

Content type: article

Language: en

Sources: [Master.dev Blog RSS Feed](<https://devfeed.tech/sources/master-dev-blog-rss-feed.md>)

Topics: [CSS](<https://devfeed.tech/topics/css.md>), [selectors](<https://devfeed.tech/topics/selectors.md>), [data type](<https://devfeed.tech/topics/data-type.md>), [Front end](<https://devfeed.tech/topics/frontend.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>), [Web Development](<https://devfeed.tech/topics/web-development.md>)

Tags: [blog-post](<https://devfeed.tech/tags/blog-post.md>), [boolean](<https://devfeed.tech/tags/boolean.md>), [boolean-type](<https://devfeed.tech/tags/boolean-type.md>), [conditional](<https://devfeed.tech/tags/conditional.md>), [container-queries](<https://devfeed.tech/tags/container-queries.md>), [css](<https://devfeed.tech/tags/css.md>), [css-custom-properties](<https://devfeed.tech/tags/css-custom-properties.md>), [css-variables](<https://devfeed.tech/tags/css-variables.md>), [custom-properties](<https://devfeed.tech/tags/custom-properties.md>), [data-type](<https://devfeed.tech/tags/data-type.md>), [has](<https://devfeed.tech/tags/has.md>), [html](<https://devfeed.tech/tags/html.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [logic](<https://devfeed.tech/tags/logic.md>), [performance](<https://devfeed.tech/tags/performance.md>), [property](<https://devfeed.tech/tags/property.md>), [scope](<https://devfeed.tech/tags/scope.md>), [style-queries](<https://devfeed.tech/tags/style-queries.md>)

### AI overview

CSS has no native boolean data type, but registered custom properties can emulate true/false flags for conditional styling. The excerpt registers `--isBackpack` and `--isDuffel` with syntax `"true | false"`, defaults them to `false`, and disables inheritance. `:has()` sets each flag on `:root` when its checkbox is checked; a named root container then exposes those values to style queries. The example uses `@container` conditions to hide products outside the selected categories, including the combined checkbox state. This replaces long checked/unchecked selector combinations with readable conditions. Registration is recommended in the excerpt for type safety, performance, and avoiding inheritance; a root container name is unnecessary when the queried property is on the direct parent or is inheritable.

### Source excerpt

CSS doesn't have a boolean type, but it does have the true and false keywords. Register a custom property that only accepts them, flip it with :has(), and container style queries turn messy :checked selector combinations into readable conditions.

## Branded Phone Type

DevFeed: [Branded Phone Type](<https://devfeed.tech/articles/branded-phone-type-122149.md>)

Original publisher: [Read original article](<https://glebbahmutov.com/blog/branded-phone-type/>)

Author: Gleb Bahmutov

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

Content type: article

Language: en

Sources: [Gleb Bahmutov](<https://devfeed.tech/sources/gleb-bahmutov.md>)

Topics: [typesafety](<https://devfeed.tech/topics/typesafety.md>), [data type](<https://devfeed.tech/topics/data-type.md>), [union types](<https://devfeed.tech/topics/union-types.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [000](<https://devfeed.tech/tags/000.md>), [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [blog](<https://devfeed.tech/tags/blog.md>), [blog-post](<https://devfeed.tech/tags/blog-post.md>), [cypress](<https://devfeed.tech/tags/cypress.md>), [phone](<https://devfeed.tech/tags/phone.md>), [process](<https://devfeed.tech/tags/process.md>), [repo](<https://devfeed.tech/tags/repo.md>), [test](<https://devfeed.tech/tags/test.md>), [testing](<https://devfeed.tech/tags/testing.md>), [type](<https://devfeed.tech/tags/type.md>), [typescript](<https://devfeed.tech/tags/typescript.md>)

### AI overview

The excerpt describes using TypeScript branded types to distinguish test and real phone numbers from ordinary strings. It defines test numbers as 10-digit strings starting with "000," and real numbers as 10-digit strings starting with neither "000" nor "555"; formatted numbers have a separate pattern. Assertion functions validate a string at runtime and let TypeScript treat it as the corresponding branded type, catching type mismatches statically while still allowing phone numbers to be used as strings. The excerpt mentions ambient `.d.ts` declarations for shared types and backend data validated on receipt.

### Source excerpt

In my previous blog post Branded Types I have shown a useful technique for repre

## Scythe: Semantic-Aware Rewriting for Fast,Effective Program Reduction

DevFeed: [Scythe: Semantic-Aware Rewriting for Fast,Effective Program Reduction](<https://devfeed.tech/articles/scythe-semantic-aware-rewriting-for-fast-effective-program-reduction-118080.md>)

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

Author: Ioanna Moraiti, Charalambos Mitropoulos, Artem Anchikov, Sotirios Ioannidis, Dimitris Mitropoulos, Thodoris Sotiropoulos

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

Content type: article

Language: en

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

Topics: [typesafety](<https://devfeed.tech/topics/typesafety.md>), [Solidity](<https://devfeed.tech/topics/solidity.md>), [semantic-layer](<https://devfeed.tech/topics/semantic-layer.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [7-4](<https://devfeed.tech/tags/7-4.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [automated](<https://devfeed.tech/tags/automated.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [c](<https://devfeed.tech/tags/c.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dependency](<https://devfeed.tech/tags/dependency.md>), [dependency-graph](<https://devfeed.tech/tags/dependency-graph.md>), [edits](<https://devfeed.tech/tags/edits.md>), [effective](<https://devfeed.tech/tags/effective.md>), [fast](<https://devfeed.tech/tags/fast.md>), [faster](<https://devfeed.tech/tags/faster.md>), [grammar](<https://devfeed.tech/tags/grammar.md>), [java](<https://devfeed.tech/tags/java.md>), [language](<https://devfeed.tech/tags/language.md>), [languages](<https://devfeed.tech/tags/languages.md>), [program](<https://devfeed.tech/tags/program.md>), [reduction](<https://devfeed.tech/tags/reduction.md>), [semantic](<https://devfeed.tech/tags/semantic.md>)

### AI overview

SCYTHE is a semantic-aware preprocessing step for grammar-based program reducers. It models declarations and their dependencies in a typed graph, then rewrites declaration-use relationships so whole declarations can be removed while keeping programs well-typed; the downstream reducer handles token-level minimization. Across 73 C, Java, and Solidity benchmarks, SCYTHE with syntactic reducer PERSES produced results no larger than PERSES alone and strictly smaller in 70 cases, averaging 55.6% smaller and 2.3x faster. With LATRA, which also uses language-specific transformations, the combination averaged 10.6% smaller results and 2.4x faster. These are reported benchmark findings; the supplied text does not describe the operators in detail.

### Source excerpt

arXiv:2611.06515v1 Announce Type: new Abstract: Automated program reduction shrinks a program into a smaller one that preserves a property of interest. Language-agnostic grammar-based reducers are easy to retarget across languages, but because they reason only about syntax, they cannot perform the coupled edits needed to remove whole declarations, e.g., a method cannot be deleted while it is still called. As a result, they waste oracle calls on edits that cannot succeed and often leave irrelevant declarations behind. We present SCYTHE, a fast, semantic-aware pre-processing step that runs in front of any grammar-based reducer without modifying it. SCYTHE encodes the program as a typed declaration dependency graph and applies a set of semantic-aware operators that decouple declarations from their use sites, making them removable while keeping the program well-typed. Fine-grained token-level minimization is then left to the downstream reducer. On 73 benchmarks across C, Java, and Solidity, combining SCYTHE with PERSES never yields a larger result than PERSES alone, and a strictly smaller one on 70 of 73 cases. On average, the combination produces programs 55.6% smaller (up to 95.5%) and is 2.3$\times$ faster (up to 7.4$\times$). SCYTHE also boosts LATRA, a reducer that, unlike the purely syntactic PERSES, also applies language-specific transformations: the combination produces programs 10.6% smaller (up to 61.8%) and is 2.4$\times$ faster on average. Video: https://youtu.be/uEq_YYU0zZw

## Imprompt: A Language Framework for Prompt Programming

DevFeed: [Imprompt: A Language Framework for Prompt Programming](<https://devfeed.tech/articles/imprompt-a-language-framework-for-prompt-programming-117261.md>)

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

Author: Chentian Wu, Shengyuan Yang, Adithya Murali

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

Content type: article

Language: en

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

Topics: [Prompt Engineering](<https://devfeed.tech/topics/prompt-engineering.md>), [prompt](<https://devfeed.tech/topics/prompt.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Programming Language Type Systems](<https://devfeed.tech/topics/programming-language-type-systems.md>), [Transpilers](<https://devfeed.tech/topics/transpilers.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>)

Tags: [case-studies](<https://devfeed.tech/tags/case-studies.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [decoding](<https://devfeed.tech/tags/decoding.md>), [foundations](<https://devfeed.tech/tags/foundations.md>), [framework](<https://devfeed.tech/tags/framework.md>), [language](<https://devfeed.tech/tags/language.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [programming](<https://devfeed.tech/tags/programming.md>), [prompt](<https://devfeed.tech/tags/prompt.md>), [prompt-engineering](<https://devfeed.tech/tags/prompt-engineering.md>), [prompting](<https://devfeed.tech/tags/prompting.md>), [study](<https://devfeed.tech/tags/study.md>), [type-checking](<https://devfeed.tech/tags/type-checking.md>)

### AI overview

Imprompt frames prompts as programs that describe tasks while leaving lower-level execution details to separate mechanisms. It presents structured prompting as prompt programming plus compilation, formally defines two compilers, and explores prompt-program typing by relating type checking to constrained decoding. The authors report implementing the compilers and type checkers and evaluating them in case studies; the excerpt does not give evaluation results.

### Source excerpt

arXiv:2607.22683v2 Announce Type: replace Abstract: With the unprecedented success of Language Models (LMs), the science of Prompt Engineering has evolved the powerful idea of Prompt Programming, where prompts are treated as a programmable control surface for describing complex tasks and leveraging LM capabilities. However, existing prompt programming frameworks suffer from various complexities and inelegances, which make them hard to utilize in practice for effectively describing tasks. We propose Imprompt, a new language framework for the study and practice of prompt programming. We undertake a foundational investigation of prompt programming, and contend that prompt programs must contain only the task descriptions and must be decoupled from lower-level 'execution' details. We further develop this position by illustrating structured prompting as a combination of prompt programming and prompt program 'compilation'. We exemplify this view by formally defining two compilers for Imprompt programs. We then explore the idea of typing for prompt programs and draw a correspondence between type checking and constrained decoding. Finally, we implement our compilers and type checkers and evaluate them on a variety of case studies. We believe our work contributes programming-language foundations toward the emerging area of prompt programming.

## Improving Partition Pruning for Cross-Type Joins in Tanzu Greenplum

DevFeed: [Improving Partition Pruning for Cross-Type Joins in Tanzu Greenplum](<https://devfeed.tech/articles/improving-partition-pruning-for-cross-type-joins-in-tanzu-greenplum-112925.md>)

Original publisher: [Read original article](<https://blogs.vmware.com/tanzu/improving-partition-pruning-for-cross-type-joins-in-tanzu-greenplum/>)

Author: VMware Community

Published: 2026-11-02T09:38:00Z

Content type: article

Language: en

Sources: [VMware](<https://devfeed.tech/sources/vmware-blogs.md>)

Topics: [database-optimization](<https://devfeed.tech/topics/database-optimization.md>), [table-partitioning](<https://devfeed.tech/topics/table-partitioning.md>), [data type](<https://devfeed.tech/topics/data-type.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>)

Tags: [constraint](<https://devfeed.tech/tags/constraint.md>), [cross](<https://devfeed.tech/tags/cross.md>), [framework](<https://devfeed.tech/tags/framework.md>), [greenplum](<https://devfeed.tech/tags/greenplum.md>), [inference](<https://devfeed.tech/tags/inference.md>), [modern-apps](<https://devfeed.tech/tags/modern-apps.md>), [partition](<https://devfeed.tech/tags/partition.md>), [vmware-tanzu-greenplum](<https://devfeed.tech/tags/vmware-tanzu-greenplum.md>)

### AI overview

GPORCA can now infer constraints through casts and other deterministic single-column expressions, allowing partition pruning for cross-type joins. In the example, a nanosecond timestamp filter is propagated through an implicit cast to a microsecond partition key, so the query can skip 364 of 366 daily partitions instead of scanning all of them. The change adds expression mapping, recursive tracing to base columns, and datetime type alignment; strict type compatibility checks are intended to prevent incorrect substitutions. Expression constraint handling is gated by the `optimizer_expression_constraints` GUC for incremental adoption, while the type correctness fixes are always active. The post says the optimization avoids query rewrites and manual redundant filters.

### Source excerpt

This technical post on VMware Tanzu Greenplum walks through the changes to GPORCA's constraint derivation framework that make partition pruning and predicate inference work for cross-type joins. The post Improving Partition Pruning for Cross-Type Joins in Tanzu Greenplum appeared first on Tanzu. The post Improving Partition Pruning for Cross-Type Joins in Tanzu Greenplum appeared first on VMware Blogs.

## Post-SQLFix: Property-Guided Repair of LLM-Generated SQL with Runtime Verification

DevFeed: [Post-SQLFix: Property-Guided Repair of LLM-Generated SQL with Runtime Verification](<https://devfeed.tech/articles/post-sqlfix-property-guided-repair-of-llm-generated-sql-with-runtime-verification-112677.md>)

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

Author: Zhihao Guo, Zonghan Wu, Yilei Shao, Haizhou Du, Nan Tang, Xiao Cheng, Huan Huo

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

Content type: article

Language: en

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

Topics: [text2sql](<https://devfeed.tech/topics/text2sql.md>), [AI for SQL query generation](<https://devfeed.tech/topics/ai-for-sql-query-generation.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>)

Tags: [analyzer](<https://devfeed.tech/tags/analyzer.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [context](<https://devfeed.tech/tags/context.md>), [contracts](<https://devfeed.tech/tags/contracts.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [diagnostics](<https://devfeed.tech/tags/diagnostics.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [execution](<https://devfeed.tech/tags/execution.md>), [framework](<https://devfeed.tech/tags/framework.md>), [identifier](<https://devfeed.tech/tags/identifier.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [invariants](<https://devfeed.tech/tags/invariants.md>), [language](<https://devfeed.tech/tags/language.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [layers](<https://devfeed.tech/tags/layers.md>), [llm](<https://devfeed.tech/tags/llm.md>), [repair](<https://devfeed.tech/tags/repair.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [sql](<https://devfeed.tech/tags/sql.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

Post-SQLFix repairs LLM-generated SQL using property-guided analysis and runtime checks instead of relying solely on execution-error messages. It canonicalizes queries into a dialect-aware Canonical Query Structure, checks syntax, structural rules, and context-sensitive semantics, then gives schema-aware diagnostics to guide repair proposals. A verify-before-apply monitor accepts changes only when they reduce violations, preserve resolved violations, and meet operator contracts; guarantees are limited to declared rules and contracts, and a finite retry budget ensures termination. Across BIRD, Spider, and Mini-Dev (over 3,000 instances, three SQL dialects, six model configurations), it resolved 77.8% of execution errors left unrepaired by execution feedback, with less than half the repair iterations and 30% fewer tokens. No accepted transition introduced a statically detectable structural regression in the evaluation; reported accuracy gains reached 11.6 percentage points.

### Source excerpt

arXiv:2610.41472v1 Announce Type: new Abstract: Large Language Models (LLMs) for Text-to-SQL frequently generate queries with syntax errors, invalid identifier references, or violations of SQL scoping and typing rules. Repairing these errors is a program correctness problem, yet existing approaches rely on Execution Feedback (EF), whose symptom-level, dialect-specific error messages force the LLM to speculate on root causes. We identify an Arbitration Paradox in this paradigm: the system relies on unverified models both to propose repairs and to make the final judgment on whether those repairs satisfy the required properties. We resolve this paradox by reformulating Text-to-SQL repair as property-guided program repair. Our framework, Post-SQLFix, canonicalizes SQL into a dialect-aware Canonical Query Structure (CQS) and validates it through a hierarchical static analyzer with three stratified property layers (Syntactic, Context-Free Structural, Context-Sensitive Semantic). The analyzer produces precise, schema-aware violation diagnostics to guide the LLM's repair proposals. A Verify-Before-Apply Temporal Monitor then accepts only repairs that reduce the violation count, do not reintroduce resolved violations, and satisfy the operator contracts. These runtime invariants are bounded by the declared rule family and operator contracts, while a finite retry budget ensures halting. On three established benchmarks (BIRD, Spider, Mini-Dev) spanning over 3,000 evaluation instances, three SQL dialects (SQLite, MySQL, PostgreSQL), and six model configurations, Post-SQLFix resolves 77.8% of the execution errors that EF leaves unrepaired, while requiring less than half as many repair iterations and 30% fewer tokens. Crucially, accepted transitions under the monitor introduce no statically detectable structural regressions in our evaluation, translating checked repair fidelity into absolute accuracy improvements of up to +11.6 percentage points.

## ZDI-26-830: Apple Safari jsToWasm IC Entrypoint Type Confusion Remote Code Execution Vulnerability

DevFeed: [ZDI-26-830: Apple Safari jsToWasm IC Entrypoint Type Confusion Remote Code Execution Vulnerability](<https://devfeed.tech/articles/zdi-26-830-apple-safari-jstowasm-ic-entrypoint-type-confusion-remote-code-execution-vulnerability-106026.md>)

Original publisher: [Read original article](<http://www.zerodayinitiative.com/advisories/ZDI-26-830/>)

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

Content type: news

Language: en

Sources: [Zero Day Initiative](<https://devfeed.tech/sources/zero-day-initiative.md>)

Topics: [typesafety](<https://devfeed.tech/topics/typesafety.md>), [Exploit](<https://devfeed.tech/topics/exploit.md>)

Tags: [apple](<https://devfeed.tech/tags/apple.md>), [code-execution](<https://devfeed.tech/tags/code-execution.md>), [interaction](<https://devfeed.tech/tags/interaction.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [remote-code-execution](<https://devfeed.tech/tags/remote-code-execution.md>), [remote-code-execution-vulnerability](<https://devfeed.tech/tags/remote-code-execution-vulnerability.md>), [safari](<https://devfeed.tech/tags/safari.md>), [type](<https://devfeed.tech/tags/type.md>), [user-interaction](<https://devfeed.tech/tags/user-interaction.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>)

### AI overview

A flaw in Apple Safari's jsToWasm IC entrypoint can cause type confusion through JavaScript actions, allowing an attacker to execute code in the current process. Exploitation requires the target to visit a malicious page or open a malicious file. The advisory gives the vulnerability a CVSS rating of 8.8 and identifies CVE-2026-86974. Apple has issued an update to address it.

### Source excerpt

This vulnerability allows remote attackers to execute arbitrary code on affected installations of Apple Safari. User interaction is required to exploit this vulnerability in that the target must visit a malicious page or open a malicious file. The ZDI has assigned a CVSS rating of 8.8. The following CVEs are assigned: CVE-2026-86974.

## AGDecode: Semantic Attribute Grammar Derivatives for Safety-Constrained Decoding of Large Language Models

DevFeed: [AGDecode: Semantic Attribute Grammar Derivatives for Safety-Constrained Decoding of Large Language Models](<https://devfeed.tech/articles/agdecode-semantic-attribute-grammar-derivatives-for-safety-constrained-decoding-of-large-language-models-103629.md>)

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

Author: Rajan Maghera, Asher Tempest Arya, Aren A. Babikian, Marsha Chechik, Maryam Mehri Dehnavi

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

Content type: article

Language: en

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

Topics: [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [LLM security](<https://devfeed.tech/topics/llm-security.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Null-Safety](<https://devfeed.tech/topics/null-safety.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [completion](<https://devfeed.tech/tags/completion.md>), [constraint](<https://devfeed.tech/tags/constraint.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [decoding](<https://devfeed.tech/tags/decoding.md>), [division-by-zero](<https://devfeed.tech/tags/division-by-zero.md>), [external](<https://devfeed.tech/tags/external.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [framework](<https://devfeed.tech/tags/framework.md>), [grammar](<https://devfeed.tech/tags/grammar.md>), [guarantees](<https://devfeed.tech/tags/guarantees.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [llms](<https://devfeed.tech/tags/llms.md>), [null](<https://devfeed.tech/tags/null.md>), [oracle](<https://devfeed.tech/tags/oracle.md>), [oracles](<https://devfeed.tech/tags/oracles.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [safety](<https://devfeed.tech/tags/safety.md>), [semantic](<https://devfeed.tech/tags/semantic.md>)

### AI overview

AGDecode constrains code generation by checking whether each token choice can still lead to a program satisfying specified semantic properties. It extends attribute grammars to partial syntax trees and compiles specifications into relational constraints checked by external verification oracles, such as SMT and CHC solvers. The authors prove soundness and completeness assuming an ideal oracle and mechanize the core metatheory in Rocq. Because real solvers can return uncertain results, the system may conservatively reject tokens or continue speculatively until later checks resolve them. In C-program generation, it enforces path-sensitive null-pointer safety, division-by-zero freedom, and initialized-variable usage, with reported modest computational overhead at regular program boundaries.

### Source excerpt

arXiv:2610.36105v1 Announce Type: new Abstract: Large language models (LLMs) are increasingly used for code generation, motivating techniques that guarantee the structural and semantic correctness of generated programs. Constrained decoding enforces correctness during generation by restricting token choices to those that admit at least one valid completion. While existing approaches can enforce syntactic constraints and selected semantic properties such as type safety, they either target specific properties or rely on operational pruning mechanisms that are difficult to generalize to data-dependent, inductive program properties. We present AGDecode, a programmable framework for semantic constrained decoding based on least-fixed-point semantics. AGDecode extends attribute grammars to partially constructed syntax trees, and reduces semantic constrained decoding to a realizability problem over such trees. The framework compiles semantic specifications into systems of relational constraints that are discharged by external verification oracles, such as SMT and CHC solvers, cleanly separating language semantics from constraint-solving machinery. We prove that our approach is sound and complete relative to an ideal verification oracle. In practice, solvers inevitably encounter uncertain queries; conservatively, our system can reject tokens for soundness or speculatively continue to generate until later queries resolve the entire generation. We mechanize the core metatheory in Rocq and evaluate the framework on semantic-constrained generation of C programs, enforcing path-sensitive safety properties including null-pointer safety, division-by-zero freedom, and initialized-variable usage. Our results demonstrate that solver-backed semantic constrained decoding can enforce rich semantic guarantees while incurring modest computational overhead at regular program boundaries.

## Pyrefly: A Fast Static Type Checker for Python Projects

DevFeed: [Pyrefly: A Fast Static Type Checker for Python Projects](<https://devfeed.tech/articles/pyrefly-a-fast-static-type-checker-for-python-projects-102214.md>)

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

Author: Cameron Riddell

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

Content type: tutorial

Language: en

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

Topics: [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [Python](<https://devfeed.tech/topics/python.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>), [Learning](<https://devfeed.tech/topics/learning.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [2-2](<https://devfeed.tech/tags/2-2.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [addition](<https://devfeed.tech/tags/addition.md>), [adopting](<https://devfeed.tech/tags/adopting.md>), [aggregation](<https://devfeed.tech/tags/aggregation.md>), [all](<https://devfeed.tech/tags/all.md>), [also](<https://devfeed.tech/tags/also.md>), [alternatives](<https://devfeed.tech/tags/alternatives.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [errors](<https://devfeed.tech/tags/errors.md>), [fast](<https://devfeed.tech/tags/fast.md>), [generate](<https://devfeed.tech/tags/generate.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [projects](<https://devfeed.tech/tags/projects.md>), [pyrefly](<https://devfeed.tech/tags/pyrefly.md>), [python](<https://devfeed.tech/tags/python.md>), [static](<https://devfeed.tech/tags/static.md>), [type](<https://devfeed.tech/tags/type.md>)

### AI overview

Pyrefly checks Python code against type hints without executing it, so `pyrefly check` can report multiple type mismatches before runtime; `pyrefly snippet` checks short examples. `pyrefly infer` adds inferred hints directly to files, but those hints reflect observed code usage and may not capture the intended interface, so review them. Coverage commands measure written hints: `coverage check` can enforce a threshold, while `coverage report` returns detailed JSON; strict mode treats `Any` as untyped, and inferred types do not count until written. The tutorial's benchmark reports Pyrefly faster than mypy and Pyright on three packages, but it is Pyrefly's own benchmark and results may vary. Existing mypy or Pyright users may face migration work and ecosystem compatibility constraints; the text suggests considering a trial before switching.

### Source excerpt

Learn how to use Pyrefly, a fast static type checker for Python, to catch type errors, generate type annotations, and measure type coverage.

## New in Symfony 8.2: Generics and Stricter Types in the Serializer

DevFeed: [New in Symfony 8.2: Generics and Stricter Types in the Serializer](<https://devfeed.tech/articles/new-in-symfony-8-2-generics-and-stricter-types-in-the-serializer-102321.md>)

Original publisher: [Read original article](<https://symfony.com/blog/new-in-symfony-8-2-generics-and-stricter-types-in-the-serializer>)

Author: Javier Eguiluz

Published: 2026-10-27T08:12:00Z

Content type: release

Language: en

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

Topics: [Symfony](<https://devfeed.tech/topics/symfony.md>), [union types](<https://devfeed.tech/topics/union-types.md>), [Type Parameter](<https://devfeed.tech/topics/type-parameter.md>), [Programming Language Type Systems](<https://devfeed.tech/topics/programming-language-type-systems.md>), [Data validation](<https://devfeed.tech/topics/data-validation.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>)

Tags: [arrays](<https://devfeed.tech/tags/arrays.md>), [collections](<https://devfeed.tech/tags/collections.md>), [generics](<https://devfeed.tech/tags/generics.md>), [json](<https://devfeed.tech/tags/json.md>), [phpdoc](<https://devfeed.tech/tags/phpdoc.md>), [symfony](<https://devfeed.tech/tags/symfony.md>), [types](<https://devfeed.tech/tags/types.md>), [union-types](<https://devfeed.tech/tags/union-types.md>)

### AI overview

Symfony 8.2 improves Serializer denormalization by resolving PHPDoc generic types from the property that holds a generic object, so nested values such as `Page<Product>` items become `Product` instances. This requires PropertyInfo's `PhpStanExtractor` and `phpstan/phpdoc-parser`; the target class name alone does not supply template types. It also denormalizes union-typed collection elements and throws when an element matches no union member or a key violates its key type. A JSON object supplied for `list<string>` still works in 8.2 but triggers a deprecation and will throw `NotNormalizableValueException` in 9.0; use a JSON array for a list, or an array type that permits meaningful keys. TypeInfo adds covariant-template support, `Type::map()` for replacing nested types, and `Type::getMismatches()` for paths and expected/actual types. Because mismatch reporting does more work, call it after `accepts()` returns false.

### Source excerpt

The Serializer component relies on the TypeInfo component to know the type of each property it denormalizes. Symfony 8.2 makes both components understand more of the types you already write in your PHPDoc, such as generics and arrays of union types, and makes...

## CodeSOD: A Type of Type Safety

DevFeed: [CodeSOD: A Type of Type Safety](<https://devfeed.tech/articles/codesod-a-type-of-type-safety-85187.md>)

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

Author: Remy Porter

Published: 2026-10-12T06:30:00Z

Content type: article

Language: en

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

Topics: [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [code](<https://devfeed.tech/tags/code.md>), [codesod](<https://devfeed.tech/tags/codesod.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [polymorphism](<https://devfeed.tech/tags/polymorphism.md>), [type-safety](<https://devfeed.tech/tags/type-safety.md>), [type-system](<https://devfeed.tech/tags/type-system.md>)

### AI overview

The article critiques a C++ codebase that uses runtime type checks and casts to restrict behavior based on object types. It explains how this approach misuses C++ casting and contrasts it with using polymorphism and dynamic dispatch to model the domain.

### Source excerpt

For some godawful reason, people like to explain object oriented concepts via analogy to biological taxonomies. I suppose it's easy to understand an "is-a" relationship (a cat is a mammal), but the down side is you get a complex and increasingly leaky analogy that over-emphasizes the importance of inheritance. That's not to slight Alan's choice of using it to anoymize today's code. It's just a broad frustration on my part. In any case, Alan has been working in a C++ codebase that's written by people who maybe don't fully understand all the key object oriented concepts. That's why you get code like this: /* * If possible, steal tentacle from the given animal. */ void Animal::StealTentacle(Animal *animal) { // only Octopus and Squid can have tentacles if (!IS_INSTANCE_OF(this, Octopus) && !IS_INSTANCE_OF(this, Squid)) { return; } Limb *limb = animal->mLimbs->GetFirstTentacle(); if (limb) { limb->AttachToAnimal(this); // . . . This function takes a raw pointer to an Animal object. If that pointer is not an Octopus or a Squid, we bail. Otherwise, we're going to take its tentacle, and do stuff with it. Now, this is a pretty clear example of the type switch anti-pattern. Instead of using the type system and polymorphism to enforce restrictions, we instead do runtime type checks. But wait a second, what's going on in that IS_INSTANCE_OF? // I've noticed that dynamic_cast always returns a valid result when // casting an "objectPointer" of type "className". // Try casting it to a [Organism *] to force it to work. (?) #define IS_INSTANCE_OF(objectPointer, className) ((bool) (dynamic_cast<className *>(((Organism *) objectPointer)) != NULL)) #define IS_MEMBER_OF(objectPointer, className) IS_INSTANCE_OF(objectPointer, className) // temporary macro alias This code attempts to take an objectPointer and first, force it into a pointer to our base type (Organism), using a C-style cast. Now, in C++, C-style casts are a shorthand, and the compiler will, based on the context, attempt to

## Adopting Pyrefly as the Python type checker at Google

DevFeed: [Adopting Pyrefly as the Python type checker at Google](<https://devfeed.tech/articles/adopting-pyrefly-as-the-python-type-checker-at-google-66435.md>)

Original publisher: [Read original article](<http://opensource.googleblog.com/2026/10/adopting-pyrefly-as-the-python-type-checker-at-google.html>)

Author: Google Open Source (noreply@blogger.com)

Published: 2026-10-06T18:30:00Z

Content type: article

Language: en

Sources: [Google Open Source Blog](<https://devfeed.tech/sources/google-open-source-blog.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>), [builds](<https://devfeed.tech/topics/builds.md>), [Google](<https://devfeed.tech/topics/google.md>)

Tags: [addition](<https://devfeed.tech/tags/addition.md>), [adopting](<https://devfeed.tech/tags/adopting.md>), [agents](<https://devfeed.tech/tags/agents.md>), [alternatives](<https://devfeed.tech/tags/alternatives.md>), [away](<https://devfeed.tech/tags/away.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [build](<https://devfeed.tech/tags/build.md>), [build-system](<https://devfeed.tech/tags/build-system.md>), [bytecode](<https://devfeed.tech/tags/bytecode.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [code](<https://devfeed.tech/tags/code.md>), [collective](<https://devfeed.tech/tags/collective.md>), [community](<https://devfeed.tech/tags/community.md>), [compute](<https://devfeed.tech/tags/compute.md>), [compute-resources](<https://devfeed.tech/tags/compute-resources.md>), [data](<https://devfeed.tech/tags/data.md>), [developer-tools](<https://devfeed.tech/tags/developer-tools.md>), [google](<https://devfeed.tech/tags/google.md>), [meta](<https://devfeed.tech/tags/meta.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [pyrefly](<https://devfeed.tech/tags/pyrefly.md>), [python](<https://devfeed.tech/tags/python.md>), [type](<https://devfeed.tech/tags/type.md>)

### AI overview

Google adopted Meta's open source Pyrefly as its Python type checker after deciding Pytype would stop supporting versions after Python 3.12. Google says Pytype's bytecode-based design made it harder to keep up with typing changes and deliver fast feedback. In internal benchmarks, Rust-based Pyrefly was about ten times faster, scored roughly 97% on the typing conformance suite, and reduced warm incremental rebuild latency by up to 98%. Cold-cache builds saw a 90-99% reduction in type checking's share of the critical path, while peak compute occupancy fell by more than 80%. Pyrefly also enforces sound union checks that Pytype historically allowed through, and provides inline diagnostics with occasional suggested fixes.

### Source excerpt

by Amer Elsheikh, Python Team Python is one of the primary languages at Google, powering everything from machine learning research to developer infrastructure and data pipelines. Across hundreds of thousands of files in our monorepo, fast and reliable static type checking is essential for maintaining code safety and developer velocity. Today, Pyrefly--an open source type checker developed by Meta--is the Python type checker at Google. Replacing our previous type-checking infrastructure with Pyrefly provided significant speedups for engineers and agents alike, while substantially reducing build-system compute resources. Moving away from Pytype For more than a decade, Google relied on Pytype, an internally developed type checker that pioneered Python type checking and collaborated with the open source community to create typeshed. However, as Python's typing system evolved rapidly, Pytype faced fundamental challenges. Because it operated by analyzing compiled bytecode rather than source ASTs, keeping pace with modern typing PEPs became an increasing maintenance burden due to bytecode instability across Python releases. In addition, it struggled to deliver the fast turnaround times required for modern development loops. As detailed in the Pytype update, we decided that Python 3.12 would be the final supported version for Pytype, leading us to evaluate and adopt modern open source alternatives. Why Pyrefly? Pyrefly incorporates years of collective lessons from earlier tools across the Python typing ecosystem. When evaluating candidates to succeed Pytype, Pyrefly quickly stood out across three key areas: Performance Written in Rust, Pyrefly is designed for high throughput and lazy, parallel evaluation. In our internal benchmarks across various Google projects, it proved to be an order of magnitude faster than Pytype, while scaling smoothly across large dependency graphs. Typing spec conformance Pyrefly achieves strong conformance--scoring roughly 97% on the official typing

## Float and integer arithmetic follow two different paradigms

DevFeed: [Float and integer arithmetic follow two different paradigms](<https://devfeed.tech/articles/float-and-integer-arithmetic-follow-two-different-paradigms-64618.md>)

Original publisher: [Read original article](<http://blog.pkh.me/p/49-float-and-integer-arithmetic-follow-two-different-paradigms.html>)

Published: 2026-10-04T16:16:40Z

Content type: article

Language: en

Sources: [Last Static](<https://devfeed.tech/sources/the-last-static-blog-rss.md>)

Topics: [floating-point](<https://devfeed.tech/topics/floating-point.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>)

Tags: [crash](<https://devfeed.tech/tags/crash.md>), [floating-point](<https://devfeed.tech/tags/floating-point.md>), [infinite](<https://devfeed.tech/tags/infinite.md>), [math](<https://devfeed.tech/tags/math.md>), [max](<https://devfeed.tech/tags/max.md>), [prevent](<https://devfeed.tech/tags/prevent.md>), [prog](<https://devfeed.tech/tags/prog.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [rust](<https://devfeed.tech/tags/rust.md>), [undefined-behavior](<https://devfeed.tech/tags/undefined-behavior.md>)

### AI overview

The article explains why floating-point and integer arithmetic require different error-handling approaches. It recommends checking whether floating-point results are finite instead of relying on arbitrary epsilon thresholds, while cautioning that finite results can still be numerically inaccurate. It also discusses limitations in GLSL and contrasts float handling with checked integer operations in C and Rust.

### Source excerpt

When working with floats, we tend to reuse the more familiar integer arithmetic patterns. More specifically, we always try to prevent a disaster rather than reacting to it. I keep noticing this pattern over and over again, and seeing that LLMs still get it wrong most of the time means that, either I am wrong, or everyone else is; it's obviously the latter, and I'm going to explain why. Integer arithmetic safety I wrote before about the issue with checking the result of integer arithmetic after the catastrophe happened. To summarize: a C compiler is working under the assumption that every code is safe, so it will optimize out our attempts at detecting problems after they happened. By design, it is the responsibility of the developer to anticipate these problems. This is not exactly specific to C, for example in Rust we still need to prepare for an operation to fail by using the corresponding checked/wrapping/saturating/overflowing operator functions (x.checked_div(y), x.saturating_add(y), etc). Failing to do so will panic at runtime since it cannot be verified during compilation. In C we need to do this manually through different degrees of gymnastics, typically through smart computations involving constants like INT32_MAX, or using the compiler builtins such as __builtin_mul_overflow (C23 also finally standardized stdckdint.h with ckd_* function helpers). Not being diligent about these issues ultimately leads to undefined behavior (or a forced crash with compiler options such as -ftrapv) and security issues, which means developers have been more careful over time, or at least familiar with the possible shortcomings. Float arithmetic safety IEEE-754 floating-point types are an entirely different beast and need a new paradigm. Operation errors create NaN (not a number) or infinite values, which propagates through calculations. They do not crash the program, and they're perfectly legitimate. Still, our habits push us to prepare for the worse, so we often see dysfunctio

## \[$\] Reducing undefined behavior in the C language

DevFeed: [\[$\] Reducing undefined behavior in the C language](<https://devfeed.tech/articles/reducing-undefined-behavior-in-the-c-language-61380.md>)

Original publisher: [Read original article](<https://lwn.net/Articles/1095811/>)

Author: corbet

Published: 2026-09-28T15:16:22Z

Content type: article

Language: en

Sources: [LWN.net](<https://devfeed.tech/sources/lwn-net.md>)

Topics: [undefined\_behavior](<https://devfeed.tech/topics/undefined-behavior.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>)

Tags: [2015](<https://devfeed.tech/tags/2015.md>), [2026](<https://devfeed.tech/tags/2026.md>), [abi](<https://devfeed.tech/tags/abi.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [annotations](<https://devfeed.tech/tags/annotations.md>), [architectures](<https://devfeed.tech/tags/architectures.md>), [array](<https://devfeed.tech/tags/array.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [buffer](<https://devfeed.tech/tags/buffer.md>), [buffer-overflow](<https://devfeed.tech/tags/buffer-overflow.md>), [bug](<https://devfeed.tech/tags/bug.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [c](<https://devfeed.tech/tags/c.md>), [c-language](<https://devfeed.tech/tags/c-language.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [language](<https://devfeed.tech/tags/language.md>), [linux](<https://devfeed.tech/tags/linux.md>), [memory](<https://devfeed.tech/tags/memory.md>), [talk](<https://devfeed.tech/tags/talk.md>), [undefined-behavior](<https://devfeed.tech/tags/undefined-behavior.md>)

### AI overview

C's undefined behavior gives implementations room for hardware support and optimization, but can leave programs without expected semantics and enable surprising compiler transformations. The article gives examples involving division by zero, observable side effects, and volatile stores, and notes that C23 added a "no time travel" rule for one such case. Mitigations include compiler warnings, static analysis, sanitizers, and formal verification; C2y's draft has removed 45 of roughly 100 instances of undefined behavior. Type and bounds safety can be improved with annotations, diagnostics, and checks, while temporal safety remains harder: Rust has an advantage, and CHERI and Fil-C can help. Full memory safety would require costly runtime checks or formal verification; the author expects the strongest near-term results from restricted C combined with formal methods.

### Source excerpt

As a professor of biomedical engineering, Martin Uecker perhaps does not fit the profile of a typical presenter at Kernel Recipes. He is, however, a longtime Linux user, and works on free software for controlling magnetic resonance imaging (MRI) scanners. He was at the conference to talk about the C programming language, the specific problem of undefined behavior in C, and whether it can eventually be made into a memory-safe language.

## JEP targeted to JDK 28: 539: Strict Field Initialization in the JVM (Preview)

DevFeed: [JEP targeted to JDK 28: 539: Strict Field Initialization in the JVM (Preview)](<https://devfeed.tech/articles/jep-targeted-to-jdk-28-539-strict-field-initialization-in-the-jvm-preview-60302.md>)

Original publisher: [Read original article](<https://inside.java/2026/09/26/jep539-target-jdk28/>)

Author: Dan Smith

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

Content type: article

Language: en

Sources: [Inside Java](<https://devfeed.tech/sources/inside-java.md>)

Topics: [openjdk](<https://devfeed.tech/topics/openjdk.md>), [JEP-401](<https://devfeed.tech/topics/jep-401.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>), [Project Valhalla](<https://devfeed.tech/topics/project-valhalla.md>)

Tags: [field](<https://devfeed.tech/tags/field.md>), [jdk](<https://devfeed.tech/tags/jdk.md>), [jdk-28](<https://devfeed.tech/tags/jdk-28.md>), [jep](<https://devfeed.tech/tags/jep.md>), [jvm](<https://devfeed.tech/tags/jvm.md>), [preview](<https://devfeed.tech/tags/preview.md>), [project-valhalla](<https://devfeed.tech/tags/project-valhalla.md>)

### AI overview

JEP 539 proposes a preview JVM feature that prevents marked fields from being read before explicit initialization, eliminating observable default values; strictly initialized final fields also cannot change after they become readable. Compilers mark fields with `ACC_STRICT_INIT`, and the JVM enforces static-field rules at run time and instance-field rules through bytecode verification. The feature is disabled by default and requires preview-enabled class files and `--enable-preview`; the JEP does not propose a new Java modifier or changes to `javac` for existing Java code. Strictly initialized final fields cannot be changed through deep reflection, and ordinary object serialization cannot handle classes declaring such instance fields unless replacement methods (`writeReplace`/`readResolve`) are used. JNI can still bypass the guarantees.

### Source excerpt

The following JEP is targeted to JDK 28: 539: Strict Field Initialization in the JVM (Preview)

## The "Downcast Trap" in Kotlin's Explicit Backing Fields

DevFeed: [The "Downcast Trap" in Kotlin's Explicit Backing Fields](<https://devfeed.tech/articles/the-downcast-trap-in-kotlin-s-explicit-backing-fields-22951.md>)

Original publisher: [Read original article](<https://proandroiddev.com/the-downcast-trap-in-kotlins-explicit-backing-fields-626ef0d66e50?source=rss----c72404660798---4>)

Author: Ehab Elwan

Published: 2026-09-13T05:31:32Z

Content type: opinion

Language: en

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

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Boilerplate](<https://devfeed.tech/topics/boilerplate.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>), [detekt](<https://devfeed.tech/topics/detekt.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [api](<https://devfeed.tech/tags/api.md>), [application](<https://devfeed.tech/tags/application.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [boilerplate](<https://devfeed.tech/tags/boilerplate.md>), [business-logic](<https://devfeed.tech/tags/business-logic.md>), [clean-code](<https://devfeed.tech/tags/clean-code.md>), [code-reviews](<https://devfeed.tech/tags/code-reviews.md>), [defensive](<https://devfeed.tech/tags/defensive.md>), [fields](<https://devfeed.tech/tags/fields.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-compiler](<https://devfeed.tech/tags/kotlin-compiler.md>), [memory](<https://devfeed.tech/tags/memory.md>), [safety](<https://devfeed.tech/tags/safety.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [stateflow](<https://devfeed.tech/tags/stateflow.md>), [type](<https://devfeed.tech/tags/type.md>), [wrapper](<https://devfeed.tech/tags/wrapper.md>)

### AI overview

Kotlin explicit backing fields remove the separate mutable and read-only properties and avoid the wrapper allocation created by `asStateFlow()`, but they weaken runtime protection. With the wrapper approach, casting the exposed `StateFlow` to `MutableStateFlow` fails; with a backing field, the underlying object remains mutable, so the cast can succeed and let callers change state outside the class. The excerpt says this tradeoff is generally acceptable for application teams, which can rely on code review and static analysis, but recommends defensive wrappers for closed-source SDKs and public libraries whose consumers cannot be trusted.

### Source excerpt

Why eliminating the double-property boilerplate changes how we protect our architecture Image generated by AIDisclosure: This article was drafted by me and refined with the help of AI tools. If you have written Kotlin in the last few years, you are intimately familiar with the double-property boilerplate. Whether in Android ViewModels or general state holders, maintaining a private mutable property alongside a public read-only property is a chore we have all accepted in the name of strict encapsulation to prevent our internal state from being hijacked by outside classes. It makes the code significantly cleaner (and slightly more memory efficient). However, it fundamentally changes how we protect our state, moving from a physical object boundary to a simple type restriction. Let's look at the tradeoff. The Old Way: Wrapper Protection For years, the standard approach to encapsulating state has looked like this: class OldViewModel { // 1. The private mutable state private val _uiState = MutableStateFlow(UiState()) // 2. The public read-only state val uiState: StateFlow<UiState> = _uiState.asStateFlow() } This is tedious to write, but it provides a strict architectural guarantee. When you call .asStateFlow(), Kotlin does not just change the type; it creates a brand new wrapper object in memory (ReadonlyStateFlow). While this physical barrier is fantastic for safety, it does mean you are incurring a minor memory allocation overhead by creating a secondary wrapper object for every exposed state. The New Way: Upcasting Explicit Backing Fields allow you to merge these two properties into one concise declaration, bypassing that extra memory allocation entirely: class NewViewModel { val uiState: StateFlow<UiState> field = MutableStateFlow(UiState()) } Inside your class, the Kotlin compiler smart-casts the field so you can mutate it internally. Outside the class, the compiler restricts callers to the read-only StateFlow interface. It looks incredibly clean and saves an allocat

## Using OxCaml to implement type-safe reference counting between OCaml and Python

DevFeed: [Using OxCaml to implement type-safe reference counting between OCaml and Python](<https://devfeed.tech/articles/using-oxcaml-to-implement-type-safe-reference-counting-between-ocaml-and-python-20199.md>)

Original publisher: [Read original article](<https://blog.janestreet.com/oxcaml-typesafe-reference-counting-python/>)

Author: Nicolas Trangez

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

Content type: article

Language: en

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

Topics: [OCaml](<https://devfeed.tech/topics/ocaml.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>), [Python](<https://devfeed.tech/topics/python.md>), [atomic reference counting](<https://devfeed.tech/topics/atomic-reference-counting.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>)

Tags: [data-analysis](<https://devfeed.tech/tags/data-analysis.md>), [data-types](<https://devfeed.tech/tags/data-types.md>), [high-performance](<https://devfeed.tech/tags/high-performance.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-management](<https://devfeed.tech/tags/memory-management.md>), [ocaml](<https://devfeed.tech/tags/ocaml.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [python](<https://devfeed.tech/tags/python.md>), [reference](<https://devfeed.tech/tags/reference.md>), [type-safe](<https://devfeed.tech/tags/type-safe.md>)

### AI overview

Jane Street's PyOCaml bridge can delay Python object deallocation when Python objects are represented as OCaml values, which is problematic for large data frames or scarce resources such as GPU memory. The excerpt says OxCaml extensions let library authors encode prompt deallocation in a typesafe way, allowing the compiler to rule out Python programs with these promptness problems. The approach uses explicit reference counting between Python and OCaml and draws on borrowing; the excerpt begins explaining Python's reference-counted object lifecycle but cuts off before detailing the implementation.

### Source excerpt

Jane Street is known for being an OCaml shop, but for years now Python has been our second major programming language, acting as the primary tool for data analysis and (especially importantly these days) machine learning. Most of our traders and researchers think and write in Python, even as the majority of our infrastructure is written in OCaml.

## Formal methods and the future of programming

DevFeed: [Formal methods and the future of programming](<https://devfeed.tech/articles/formal-methods-and-the-future-of-programming-20167.md>)

Original publisher: [Read original article](<https://blog.janestreet.com/formal-methods-at-jane-street-index/>)

Author: Yaron Minsky

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

Content type: opinion

Language: en

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

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>)

Tags: [agentic-coding](<https://devfeed.tech/tags/agentic-coding.md>), [agents](<https://devfeed.tech/tags/agents.md>), [building-software](<https://devfeed.tech/tags/building-software.md>), [c](<https://devfeed.tech/tags/c.md>), [code](<https://devfeed.tech/tags/code.md>), [formal-methods](<https://devfeed.tech/tags/formal-methods.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [models](<https://devfeed.tech/tags/models.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [software](<https://devfeed.tech/tags/software.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [synthesis](<https://devfeed.tech/tags/synthesis.md>), [tools](<https://devfeed.tech/tags/tools.md>), [type-systems](<https://devfeed.tech/tags/type-systems.md>)

### AI overview

Jane Street says agentic coding has shifted its view of formal methods: models can make verification tools easier for more people to use, changing the cost-benefit calculation. The excerpt contrasts this possibility with seL4, whose verification reportedly took 25 person-years for 8,700 lines of C, and notes that formal methods had previously seemed too expensive for most software, even critical systems. The passage begins to discuss growing benefits as models write more code, but cuts off before explaining them.

### Source excerpt

I've been telling people for the last 25 years that Jane Street as an organization was just not interested in formal methods.

## What's New in Apollo Client 4.2

DevFeed: [What's New in Apollo Client 4.2](<https://devfeed.tech/articles/what-s-new-in-apollo-client-4-2-23586.md>)

Original publisher: [Read original article](<https://www.apollographql.com/blog/whats-new-in-apollo-client-4-2>)

Author: Jerel Miller

Published: 2026-05-27T11:33:11Z

Content type: release

Language: en

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

Topics: [apollo-client](<https://devfeed.tech/topics/apollo-client.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>), [React](<https://devfeed.tech/topics/react.md>)

Tags: [announcement](<https://devfeed.tech/tags/announcement.md>), [apollo](<https://devfeed.tech/tags/apollo.md>), [apollo-client](<https://devfeed.tech/tags/apollo-client.md>), [event](<https://devfeed.tech/tags/event.md>), [focus](<https://devfeed.tech/tags/focus.md>), [type-safe](<https://devfeed.tech/tags/type-safe.md>)

### AI overview

Apollo Client 4.2 propagates declared default options through React hooks and core APIs so TypeScript types reflect runtime behavior. Opting in requires TypeScript module augmentation and a matching runtime option. Generic arguments to hooks and core APIs are deprecated; they remain usable but do not provide the new type safety, so the excerpt points readers to migration guidance. The release also introduces event-based refetching for events such as window focus and network reconnection, replacing the need to build this behavior with custom event handling or wrapper hooks. The excerpt ends while describing how to configure it.

### Source excerpt

Discover Apollo Client 4.2's type-safe default options and event-based refetching. Eliminate type mismatches and automatically refetch on window focus. Learn how.

## JavaScript source maps

DevFeed: [JavaScript source maps](<https://devfeed.tech/articles/javascript-source-maps-51507.md>)

Original publisher: [Read original article](<https://gleam.run/news/javascript-source-maps>)

Author: Louis Pilfold

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

Content type: release

Language: en

Sources: [Gleam](<https://devfeed.tech/sources/gleam.md>)

Topics: [Compilers and Linkers](<https://devfeed.tech/topics/compilers-and-linkers.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Developer Tools](<https://devfeed.tech/topics/developer-tools.md>), [Erlang](<https://devfeed.tech/topics/erlang.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>), [Build tool](<https://devfeed.tech/topics/build-tool.md>), [browser](<https://devfeed.tech/topics/browser.md>), [Transpilers](<https://devfeed.tech/topics/transpilers.md>), [IntelliJ IDEA](<https://devfeed.tech/topics/intellij-idea.md>)

Tags: [breakpoint](<https://devfeed.tech/tags/breakpoint.md>), [browser](<https://devfeed.tech/tags/browser.md>), [browsers](<https://devfeed.tech/tags/browsers.md>), [debug](<https://devfeed.tech/tags/debug.md>), [debuggers](<https://devfeed.tech/tags/debuggers.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [dev-tools](<https://devfeed.tech/tags/dev-tools.md>), [exception](<https://devfeed.tech/tags/exception.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [maps](<https://devfeed.tech/tags/maps.md>), [safari](<https://devfeed.tech/tags/safari.md>), [source](<https://devfeed.tech/tags/source.md>)

### AI overview

Gleam v1.16.0 adds JavaScript source maps so browser tools can show original Gleam locations in code, stack traces, and debugging sessions; enable them with `javascript.source_maps = true` and serve the generated map files. Serving the build directory or using Lustre's dev-tools already handles that. The release also improves language-server fault tolerance by reporting imports that lead to compilation failures and continuing with compilable module branches. Other changes include nearly 30% faster single-character string-prefix matching in the cited `glance` benchmark, a warning for JavaScript integer patterns wider than its 52-bit precision limit, package owner management, and additional code actions and compiler improvements.

### Source excerpt

Gleam is a type safe and scalable language for the Erlang virtual machine and JavaScript runtimes. Today Gleam v1.16.0 has been published, let's go over what's new. Gleam gets source maps Gleam's robust type system makes runtime errors very rare, but it would be naive to say that it's never necessary to debug Gleam code at runtime. When compiling code to JavaScript one challenge for runtime debugging is that the error and the source code shown is that of the compiled JavaScript, not the Gleam the programmer actually wrote. The solution to this problem is source maps, additional files that Gleam's compiler can now generate, teaching browsers and JavaScript runtimes what the original code is and how it maps on to the JavaScript it runs. Here it is in action with Safari's dev-tools: As you may know, it's not limited to just displaying the code, it also translates exception stack traces to the original locations, and enables use of breakpoints and debuggers. To enable source maps set the javascript.source_maps property to true in your gleam.toml, and ensure that you are serving these new files to the web browser along with your JavaScript code. If you are serving the build directory or using Lustre's dev-tools then there's nothing else to do. name = "my_project" version = "1.0.0" [javascript] source_maps = true [dependencies] gleam_stdlib = ">= 1.0.0 and < 2.0.0" A huge thank you to Ameen Radwan for this big improvement. Folks who enjoy breakpoint debugging will be especially pleased. Package-level fault tolerance Gleam is a fully-typed language, so to compile a module of Gleam code the compiler must first successfully compile all the modules it imports in order to have the required type information. Attempting to analyse modules without this information would result in a cascading failure of incorrect and misleading error messages, so when a module cannot be compiled the build tool stops and reports the errors. This behaviour successfully prevents the error cascade, bu

## Type-Safe Caching in Encore.ts

DevFeed: [Type-Safe Caching in Encore.ts](<https://devfeed.tech/articles/type-safe-caching-in-encore-ts-17857.md>)

Original publisher: [Read original article](<https://encore.dev/blog/type-safe-caching>)

Author: Ivan Cernja

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

Content type: article

Language: en

Sources: [Encore Updates](<https://devfeed.tech/sources/encore-updates.md>)

Topics: [Redis](<https://devfeed.tech/topics/redis.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>), [Back end](<https://devfeed.tech/topics/backend.md>)

Tags: [caching](<https://devfeed.tech/tags/caching.md>), [redis](<https://devfeed.tech/tags/redis.md>), [type-safe](<https://devfeed.tech/tags/type-safe.md>), [typescript](<https://devfeed.tech/tags/typescript.md>)

### AI overview

Stringly typed Redis caching loses TypeScript's guarantees at the cache boundary: values are cast back on read, so changed data shapes, overlapping key patterns, and naming mistakes may escape compile-time checks and surface after deployment. The excerpt says Encore.ts v1.55 introduces typed keyspaces that define key structure, value type, and Redis key mapping. The compiler checks reads and writes, distinct keyspaces constrain patterns and value types to reduce accidental collisions or cross-reads, and each keyspace exposes operations suited to its Redis data structure. The excerpt ends mid-sentence and does not provide the full API details.

### Source excerpt

What goes wrong with stringly-typed Redis, and what changes when the cache boundary is typed.

## Winter of Quality 2026

DevFeed: [Winter of Quality 2026](<https://devfeed.tech/articles/winter-of-quality-2026-19183.md>)

Original publisher: [Read original article](<https://code.blender.org/2026/02/winter-of-quality-2026/>)

Author: Thomas Dinges

Published: 2026-02-16T12:11:43Z

Content type: news

Language: en

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

Topics: [blender](<https://devfeed.tech/topics/blender.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [open source maintenance](<https://devfeed.tech/topics/open-source-maintenance.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Tech Debt](<https://devfeed.tech/topics/tech-debt.md>), [Code Health](<https://devfeed.tech/topics/code-health.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [automated](<https://devfeed.tech/tags/automated.md>), [blender](<https://devfeed.tech/tags/blender.md>), [bugfixes](<https://devfeed.tech/tags/bugfixes.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [core](<https://devfeed.tech/tags/core.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [development](<https://devfeed.tech/tags/development.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [general-development](<https://devfeed.tech/tags/general-development.md>), [geometry-nodes](<https://devfeed.tech/tags/geometry-nodes.md>), [kernels](<https://devfeed.tech/tags/kernels.md>), [lighting](<https://devfeed.tech/tags/lighting.md>), [memory-safe](<https://devfeed.tech/tags/memory-safe.md>), [performance](<https://devfeed.tech/tags/performance.md>), [quality](<https://devfeed.tech/tags/quality.md>), [winter](<https://devfeed.tech/tags/winter.md>)

### AI overview

During the 2025-2026 northern winter, Blender developers prioritized stability and quality. From December 1 through January 31, they fixed more than 350 reported issues across modules, rechecked older reports, and addressed issues users had not reported. The excerpt also describes technical debt work, documentation, tests, and stabilization. Examples include compositor refactoring toward reusable node trees, Core changes toward safer C++ data structures and functions, and a roughly 10% reduction in legacy dependency-graph tagging. Blender completed the mesh-attribute transition to Attribute Storage, enabling optional storage of attribute arrays as single values in Blender 5.1. Other work included modeling fixes, modernizing GHOST to C++, consolidating build repositories, and refactoring render-kernel lighting. The article excerpt is partial and does not provide the full module-by-module work overview.

### Source excerpt

During the (northern) winter of 2025-2026, the Blender development team prioritized improving stability and overall quality.

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