UFRGS
AI Insights
- Software Engineering is becoming sharper and more demanding as automation absorbs construction. (ML: 0.97)
- The discipline's legitimacy rests on its ability to articulate intent, enforce constraints, and establish trust in systems humans no longer directly build. (ML: 0.97)
- Software Engineering's central contribution is no longer only efficient production, but also the prevention of accountability collapse in automated systems. (ML: 0.96)
- Lack of clear guidelines for intent articulation Insufficient attention to the human-AI collaboration aspect (ML: 0.96)
- Software Engineering becomes the discipline of deciding what should exist, what must not, and how we verify the difference. (ML: 0.95)
- SDLC (Software Development Life Cycle): A series of phases involved in creating a software product Automation: The use of machines or computers to perform tasks automatically Intent articulation: The process of clearly defining what a system should do and how it should behave The future of Software Engineering is not faster coding, but rather a detailed, more deliberate judgment while undergoing the unprecedented pressure from automation. (ML: 0.95)
Abstract
Software Engineering (SE) faces simultaneous pressure from AI automation (reducing code production costs) and hardware-energy constraints (amplifying failure costs). We position that SE must redefine itself around human discernment-intent articulation, architectural control, and verification-rather than code construction. This shift introduces accountability collapse as a central risk and requires fundamental changes to research priorities, educational curricula, and industrial practices. We argue that Software Engineering, as traditionally defined around code construction and process management, is no longer sufficient. Instead, the discipline must be redefined around intent articulation, architectural control, and systematic verification. This redefinition shifts Software Engineering from a production-oriented field to one centered on human judgment under automation, with profound implications for research, practice, and education.
Software Engineering (SE) faces simultaneous pressure from AI automation (reducing code production costs) and hardware-energy constraints (amplifying failure costs). We position that SE must redefine itself around human discernment-intent articulation, architectural control, and verification-rather than code construction. This shift introduces accountability collapse as a central risk and requires fundamental changes to research priorities, educational curricula, and industrial practices. We argue that Software Engineering, as traditionally defined around code construction and process management, is no longer sufficient. Instead, the discipline must be redefined around intent articulation, architectural control, and systematic verification. This redefinition shifts Software Engineering from a production-oriented field to one centered on human judgment under automation, with profound implications for research, practice, and education.
Why we are recommending this paper?
Due to your Interest in Programming Paradigms
This paper explores fundamental shifts in software engineering, aligning with your interest in programming paradigms and design patterns. The focus on verification and orchestration directly relates to building robust and reliable systems.
Due to your Interest in Programming Paradigms
This paper explores fundamental shifts in software engineering, aligning with your interest in programming paradigms and design patterns. The focus on verification and orchestration directly relates to building robust and reliable systems.
University of California, Berkeley
AI Insights
- The proof relies on a number of technical assumptions, which may limit its applicability to more general cases. (ML: 0.86)
- The result has implications for the study of permutation statistics and their relationships with other combinatorial structures. (ML: 0.85)
- Permutahedral variety: A geometric object that encodes information about permutations and their relationships. (ML: 0.84)
- Forest polynomial: A polynomial associated with a forest, which is a collection of trees. (ML: 0.81)
- Schubert polynomial: A polynomial that encodes information about the combinatorial structure of permutations. (ML: 0.78)
- The problem is about the relationship between forest polynomials and the class of the permutahedral variety. (ML: 0.75)
- The authors use a combination of combinatorial and algebraic techniques to prove that certain patterns in Schubert polynomials are equivalent to specific configurations in the permutahedral variety. (ML: 0.72)
- The authors prove that certain patterns in Schubert polynomials are equivalent to specific configurations in the permutahedral variety, providing a new understanding of the relationship between these two objects. (ML: 0.70)
- The authors build on previous work by Nantel Bergeron, Sara Billey, and Richard Stanley on Schubert polynomials and their relationships with other combinatorial structures. (ML: 0.69)
- The relationship between forest polynomials and the permutahedral variety is still not fully understood, and further research is needed to clarify this connection. (ML: 0.64)
Abstract
Forest polynomials, recently introduced by Nadeau and Tewari, can be thought of as a quasisymmetric analogue for Schubert polynomials. They have already been shown to exhibit interesting interactions with Schubert polynomials; for example, Schubert polynomials decompose positively into forest polynomials. We further describe this relationship by showing that a Schubert polynomial $\mathfrak{S}_w$ is a forest polynomial exactly when $w$ avoids a set of $6$ patterns. This result adds to the long list of properties of Schubert polynomials that are controlled by pattern avoidance.
Forest polynomials, recently introduced by Nadeau and Tewari, can be thought of as a quasisymmetric analogue for Schubert polynomials. They have already been shown to exhibit interesting interactions with Schubert polynomials; for example, Schubert polynomials decompose positively into forest polynomials. We further describe this relationship by showing that a Schubert polynomial $\mathfrak{S}_w$ is a forest polynomial exactly when $w$ avoids a set of $6$ patterns. This result adds to the long list of properties of Schubert polynomials that are controlled by pattern avoidance.
Why we are recommending this paper?
Due to your Interest in Design Patterns
The exploration of forest polynomials and their connection to Schubert polynomials offers a unique perspective on pattern avoidance, a core concept in programming language design. This research delves into mathematical structures relevant to algorithmic design.
Due to your Interest in Design Patterns
The exploration of forest polynomials and their connection to Schubert polynomials offers a unique perspective on pattern avoidance, a core concept in programming language design. This research delves into mathematical structures relevant to algorithmic design.
Zhejiang University
AI Insights
- Poisoning rate (ρ): the proportion of poisoned samples in the training dataset. (ML: 0.97)
- SCD uses a contrastive decoding process that extracts functional requirements from the input and filters out malicious triggers. (ML: 0.88)
- Attack success rate (ASR): the percentage of successful attacks on the model. (ML: 0.87)
- Experiments on three datasets show that SCD is effective in suppressing attack success rates (ASR) to below 10% across all poisoning rates and model scales. (ML: 0.86)
- Backdoor attacks: a type of adversarial attack where an attacker poisons the training data to implant a backdoor in the model. (ML: 0.81)
- The authors also investigate the impact of poisoning rate and model scale on attack strength and defense effectiveness, finding that SCD maintains robust defense regardless of these factors. (ML: 0.77)
- The paper presents a robust defense mechanism, SCD, that can effectively suppress ASR across various poisoning rates and model scales. (ML: 0.75)
- SCD's inference-time defense mechanism operates independently of training-time poisoning, providing consistent protection regardless of how the backdoor was implanted. (ML: 0.65)
- Self-Contrastive Decoding (SCD): a novel approach to defending against backdoor attacks using contrastive decoding and functional requirement extraction. (ML: 0.63)
- The paper presents a novel approach to defending against backdoor attacks in code generation models, called Self-Contrastive Decoding (SCD). (ML: 0.63)
Abstract
Large language models (LLMs) for Verilog code generation are increasingly adopted in hardware design, yet remain vulnerable to backdoor attacks where adversaries inject malicious triggers during training to induce vulnerable hardware designs. Unlike patchable software vulnerabilities, hardware trojans become irreversible once fabricated, making remediation extremely costly or impossible. Existing active defenses require access to training data, impractical for third-party LLM users, while passive defenses struggle against semantically stealthy triggers that naturally blend into design specifications. In this paper, we hypothesize that under the requirements of both effectiveness and stealthiness, attackers are strongly biased toward embedding triggers in non-functional requirements (e.g., style modifiers, quality descriptors) rather than functional specifications that determine hardware behavior. Exploiting this insight, we propose Semantic Consensus Decoding (SCD), an inference-time passive defense with two key components: (1) functional requirement extraction that identifies essential requirements from user specifications, and (2) consensus decoding that adaptively fuses output distributions based on full user specifications and extracted functional requirements. When these distributions diverge significantly, SCD automatically suppresses suspicious components. Extensive experiments with three representative backdoor attacks demonstrate that SCD reduces average attack success rate from 89% to under 3% with negligible impact on generation quality.
Large language models (LLMs) for Verilog code generation are increasingly adopted in hardware design, yet remain vulnerable to backdoor attacks where adversaries inject malicious triggers during training to induce vulnerable hardware designs. Unlike patchable software vulnerabilities, hardware trojans become irreversible once fabricated, making remediation extremely costly or impossible. Existing active defenses require access to training data, impractical for third-party LLM users, while passive defenses struggle against semantically stealthy triggers that naturally blend into design specifications. In this paper, we hypothesize that under the requirements of both effectiveness and stealthiness, attackers are strongly biased toward embedding triggers in non-functional requirements (e.g., style modifiers, quality descriptors) rather than functional specifications that determine hardware behavior. Exploiting this insight, we propose Semantic Consensus Decoding (SCD), an inference-time passive defense with two key components: (1) functional requirement extraction that identifies essential requirements from user specifications, and (2) consensus decoding that adaptively fuses output distributions based on full user specifications and extracted functional requirements. When these distributions diverge significantly, SCD automatically suppresses suspicious components. Extensive experiments with three representative backdoor attacks demonstrate that SCD reduces average attack success rate from 89% to under 3% with negligible impact on generation quality.
Why we are recommending this paper?
Due to your Interest in Programming Language Design
Given your interest in programming language design, this paper's focus on Verilog code generation and backdoor defenses is highly relevant. Understanding vulnerabilities in hardware design is crucial for secure software development.
Due to your Interest in Programming Language Design
Given your interest in programming language design, this paper's focus on Verilog code generation and backdoor defenses is highly relevant. Understanding vulnerabilities in hardware design is crucial for secure software development.
Nara Institute of Science and Technology
AI Insights
- The text assumes that readers are familiar with OSS-Fuzz, ClusterFuzz, and heap-use-after-free bugs. (ML: 0.93)
- OSS-Fuzz: An open-source fuzz testing framework developed by Google. (ML: 0.81)
- ClusterFuzz: A distributed fuzz testing system that uses OSS-Fuzz as its backend. (ML: 0.81)
- The text does not provide enough information to understand the exact fix for the bug. (ML: 0.78)
- Heap-use-after-free: A type of memory corruption bug where a program accesses memory after it has been freed. (ML: 0.76)
- The bug was not considered a vulnerability because it only occurred when handling arbitrary or corrupt input. (ML: 0.76)
- The bug was fixed by a commit that changed the way audio data is handled in the library. (ML: 0.68)
- The bug was a heap-use-after-free issue in the unpack_dsd_samples function of the wavpack library. (ML: 0.66)
- The bug was fixed and made public on OSS-Fuzz's issue tracker, but the exact fix is not described in the provided text. (ML: 0.57)
- The fix was verified by ClusterFuzz and made public on OSS-Fuzz's issue tracker. (ML: 0.55)
Abstract
Fuzzing has become a popular technique for automatically detecting vulnerabilities and bugs by generating unexpected inputs. In recent years, the fuzzing process has been integrated into continuous integration workflows (i.e., continuous fuzzing), enabling short and frequent testing cycles. Despite its widespread adoption, prior research has not examined whether the effectiveness of continuous fuzzing varies across programming languages. This study conducts a large-scale cross-language analysis to examine how fuzzing bug characteristics and detection efficiency differ among languages. We analyze 61,444 fuzzing bugs and 999,248 builds from 559 OSS-Fuzz projects categorized by primary language. Our findings reveal that (i) C++ and Rust exhibit higher fuzzing bug detection frequencies, (ii) Rust and Python show low vulnerability ratios but tend to expose more critical vulnerabilities, (iii) crash types vary across languages and unreproducible bugs are more frequent in Go but rare in Rust, and (iv) Python attains higher patch coverage but suffers from longer time-to-detection. These results demonstrate that fuzzing behavior and effectiveness are strongly shaped by language design, providing insights for language-aware fuzzing strategies and tool development.
Fuzzing has become a popular technique for automatically detecting vulnerabilities and bugs by generating unexpected inputs. In recent years, the fuzzing process has been integrated into continuous integration workflows (i.e., continuous fuzzing), enabling short and frequent testing cycles. Despite its widespread adoption, prior research has not examined whether the effectiveness of continuous fuzzing varies across programming languages. This study conducts a large-scale cross-language analysis to examine how fuzzing bug characteristics and detection efficiency differ among languages. We analyze 61,444 fuzzing bugs and 999,248 builds from 559 OSS-Fuzz projects categorized by primary language. Our findings reveal that (i) C++ and Rust exhibit higher fuzzing bug detection frequencies, (ii) Rust and Python show low vulnerability ratios but tend to expose more critical vulnerabilities, (iii) crash types vary across languages and unreproducible bugs are more frequent in Go but rare in Rust, and (iv) Python attains higher patch coverage but suffers from longer time-to-detection. These results demonstrate that fuzzing behavior and effectiveness are strongly shaped by language design, providing insights for language-aware fuzzing strategies and tool development.
Why we are recommending this paper?
Due to your Interest in Programming Language Design
This study investigates the impact of programming language on bug detection techniques, directly addressing your interest in programming language design and its influence on software quality.
Due to your Interest in Programming Language Design
This study investigates the impact of programming language on bug detection techniques, directly addressing your interest in programming language design and its influence on software quality.
University of Minnesota
AI Insights
- The key insights are: (1) the probability of acceptance depends only on the adversarial noise through its magnitude distribution, and (2) the conditional MSE can be expressed as a function of the probability of acceptance and the marginal magnitude PDF of the adversarial noise. (ML: 0.94)
- Conditional MSE: The expected value of the estimation error given that the DC has accepted the computation. (ML: 0.93)
- Probability of acceptance: The probability that the DC accepts the computation given the honest and adversarial noise vectors. (ML: 0.92)
- The problem is solved by characterizing the probability of acceptance and the conditional MSE in terms of the marginal magnitude PDF of the adversarial noise, and then simplifying the search space for the worst-case adversarial noise distribution. (ML: 0.89)
- Adversarial noise distribution: A distribution over the space of possible noise vectors that an adversary may introduce to the system. (ML: 0.88)
- The solution requires characterizing the probability of acceptance and the conditional MSE in terms of the marginal magnitude PDF of the adversarial noise. (ML: 0.87)
- The solution does not consider the case where the adversary has access to the honest noise vector. (ML: 0.80)
- The problem involves finding the worst-case adversarial noise distribution that maximizes the estimation error of a DC protocol. (ML: 0.80)
- The solution assumes that the DC protocol is designed to detect and reject malicious computations. (ML: 0.79)
- The solution provides a framework for analyzing the robustness of DC protocols to adversarial attacks. (ML: 0.70)
Abstract
The game of coding is a new framework at the intersection of game theory and coding theory; designed to transcend the fundamental limitations of classical coding theory. While traditional coding theoretic schemes rely on a strict trust assumption, that honest nodes must outnumber adversarial ones to guarantee valid decoding, the game of coding leverages the economic rationality of actors to guarantee correctness and reliable decodability, even in the presence of an adversarial majority. This capability is paramount for emerging permissionless applications, particularly decentralized machine learning (DeML). However, prior investigations into the game of coding have been strictly confined to scalar computations, limiting their applicability to real world tasks where high dimensional data is the norm. In this paper, we bridge this gap by extending the framework to the general $N$-dimensional Euclidean space. We provide a rigorous problem formulation for vector valued computations and fully characterize the equilibrium strategies of the resulting high dimensional game. Our analysis demonstrates that the resilience properties established in the scalar setting are preserved in the vector regime, establishing a theoretical foundation for secure, large scale decentralized computing without honest majority assumptions.
The game of coding is a new framework at the intersection of game theory and coding theory; designed to transcend the fundamental limitations of classical coding theory. While traditional coding theoretic schemes rely on a strict trust assumption, that honest nodes must outnumber adversarial ones to guarantee valid decoding, the game of coding leverages the economic rationality of actors to guarantee correctness and reliable decodability, even in the presence of an adversarial majority. This capability is paramount for emerging permissionless applications, particularly decentralized machine learning (DeML). However, prior investigations into the game of coding have been strictly confined to scalar computations, limiting their applicability to real world tasks where high dimensional data is the norm. In this paper, we bridge this gap by extending the framework to the general $N$-dimensional Euclidean space. We provide a rigorous problem formulation for vector valued computations and fully characterize the equilibrium strategies of the resulting high dimensional game. Our analysis demonstrates that the resilience properties established in the scalar setting are preserved in the vector regime, establishing a theoretical foundation for secure, large scale decentralized computing without honest majority assumptions.
Why we are recommending this paper?
Due to your Interest in Functional Programming
The paper's novel framework at the intersection of game theory and coding theory aligns with your interest in programming paradigms and potentially offers new approaches to algorithm design and optimization.
Due to your Interest in Functional Programming
The paper's novel framework at the intersection of game theory and coding theory aligns with your interest in programming paradigms and potentially offers new approaches to algorithm design and optimization.
Universidad de Guadalajara
AI Insights
- It was shown in [5, Corollary 1], that if G is a torsion-free abelian group, then every non-constant generalized Set-cellular automaton has a unique factorization; this result was generalized in [14] by removing the hypothesis of G being abelian. (ML: 0.84)
- The factorization of generalized C-cellular automata given by Lemma 4.5 is not unique in general. (ML: 0.79)
- A categorical outlook on cellular automata Generalized cellu- lar automata Categorical products of cellular automata Weak product The weak product given in Theorem 4.7 is not a product in GCA Set, but it is an open question if a product actually exists in GCA Set. (ML: 0.76)
- The problem with showing that the weak product given in Theorem 4.7 is unique, and hence a product, is that the factorization of generalized C-cellular automata given by Lemma 4.5 is not unique in general. (ML: 0.73)
- It is an open question if a product actually exists in GCA Set. (ML: 0.72)
- The article cites several papers on the topic, including [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12], [13], and [14]. (ML: 0.64)
Abstract
This paper proposes a generalized framework for cellular automata using the language of category theory, extending the classical definition beyond set-theoretic constraints. For an arbitrary category $\mathscr{C}$ with products, we define $\mathscr{C}$-cellular automata as morphisms $τ: A^G \to B^G$ in $\mathscr{C}$, where the alphabets $A$ and $B$ are objects in $\mathscr{C}$ and the universe is a group $G$. We show that $\mathscr{C}$-cellular automata form a subcategory of $\mathscr{C}$ closed under finite products, and that they satisfy a categorical version of the Curtis-Hedlund-Lyndon theorem. For two arbitrary group universes $G$ and $H$, we extend our theory to define generalized $\mathscr{C}$-cellular automata as morphisms $τ: A^G \to B^H$ constructed via a group homomorphism $φ: H \to G$. Finally, we prove that generalized $\mathscr{C}$-cellular automata form a subcategory of $\mathscr{C}$ with a finite weak product involving the free product of the underlying group universes. This framework unifies existing concepts and provides purely categorical proofs of foundational results in the theory of cellular automata.
This paper proposes a generalized framework for cellular automata using the language of category theory, extending the classical definition beyond set-theoretic constraints. For an arbitrary category $\mathscr{C}$ with products, we define $\mathscr{C}$-cellular automata as morphisms $τ: A^G \to B^G$ in $\mathscr{C}$, where the alphabets $A$ and $B$ are objects in $\mathscr{C}$ and the universe is a group $G$. We show that $\mathscr{C}$-cellular automata form a subcategory of $\mathscr{C}$ closed under finite products, and that they satisfy a categorical version of the Curtis-Hedlund-Lyndon theorem. For two arbitrary group universes $G$ and $H$, we extend our theory to define generalized $\mathscr{C}$-cellular automata as morphisms $τ: A^G \to B^H$ constructed via a group homomorphism $φ: H \to G$. Finally, we prove that generalized $\mathscr{C}$-cellular automata form a subcategory of $\mathscr{C}$ with a finite weak product involving the free product of the underlying group universes. This framework unifies existing concepts and provides purely categorical proofs of foundational results in the theory of cellular automata.
Why we are recommending this paper?
Due to your Interest in Programming Paradigms
Due to your Interest in Programming Paradigms
Princeton University
AI Insights
- However, there are still challenges to be addressed, such as improving sample efficiency, generalizing to new environments, and scaling up to complex tasks. (ML: 0.98)
- Generalization: RL models may not generalize well to new environments or tasks, requiring retraining from scratch. (ML: 0.98)
- Sample efficiency: RL methods often require large amounts of data to learn effective policies, which can be time-consuming and expensive. (ML: 0.97)
- Imagine you're trying to learn how to play a video game. (ML: 0.96)
- Reinforcement learning is a subfield of machine learning that involves training agents to take actions in an environment to maximize a reward signal. (ML: 0.96)
- That's basically what reinforcement learning is – it's a way for computers to learn from experience and get better at doing things. (ML: 0.96)
- Reinforcement learning (RL) is a subfield of machine learning that involves training agents to take actions in an environment to maximize a reward signal. (ML: 0.96)
- Scalability: As tasks become more complex, RL methods can struggle to scale up, leading to increased computational costs. (ML: 0.95)
- As you play more, you start to notice patterns and figure out which actions lead to the best rewards (like getting extra lives or points). (ML: 0.94)
- RL has been successful in various applications, including robotics, game playing, and autonomous driving. (ML: 0.91)
- Recent papers have explored various aspects of RL, including model-based and model-free methods, offline RL, and transfer learning. (ML: 0.91)
- Some notable results include the development of new algorithms for improving sample efficiency and generalization, as well as applications in robotics, game playing, and autonomous driving. (ML: 0.89)
- Model-based RL: A type of RL where the agent learns a model of the environment and uses it to plan its actions. (ML: 0.89)
- Model-free RL: A type of RL where the agent learns directly from experience without learning a model of the environment. (ML: 0.87)
- You start by making random moves and seeing what happens. (ML: 0.83)
- RL has made significant progress in recent years, with many state-of-the-art results achieved through model-based and model-free methods. (ML: 0.65)
Abstract
How does the amount of compute available to a reinforcement learning (RL) policy affect its learning? Can policies using a fixed amount of parameters, still benefit from additional compute? The standard RL framework does not provide a language to answer these questions formally. Empirically, deep RL policies are often parameterized as neural networks with static architectures, conflating the amount of compute and the number of parameters. In this paper, we formalize compute bounded policies and prove that policies which use more compute can solve problems and generalize to longer-horizon tasks that are outside the scope of policies with less compute. Building on prior work in algorithmic learning and model-free planning, we propose a minimal architecture that can use a variable amount of compute. Our experiments complement our theory. On a set 31 different tasks spanning online and offline RL, we show that $(1)$ this architecture achieves stronger performance simply by using more compute, and $(2)$ stronger generalization on longer-horizon test tasks compared to standard feedforward networks or deep residual network using up to 5 times more parameters.
How does the amount of compute available to a reinforcement learning (RL) policy affect its learning? Can policies using a fixed amount of parameters, still benefit from additional compute? The standard RL framework does not provide a language to answer these questions formally. Empirically, deep RL policies are often parameterized as neural networks with static architectures, conflating the amount of compute and the number of parameters. In this paper, we formalize compute bounded policies and prove that policies which use more compute can solve problems and generalize to longer-horizon tasks that are outside the scope of policies with less compute. Building on prior work in algorithmic learning and model-free planning, we propose a minimal architecture that can use a variable amount of compute. Our experiments complement our theory. On a set 31 different tasks spanning online and offline RL, we show that $(1)$ this architecture achieves stronger performance simply by using more compute, and $(2)$ stronger generalization on longer-horizon test tasks compared to standard feedforward networks or deep residual network using up to 5 times more parameters.
Why we are recommending this paper?
Due to your Interest in Functional Programming
Due to your Interest in Functional Programming
Interests not found
We did not find any papers that match the below interests.
Try other terms also consider if the content exists in arxiv.org.
- Object Oriented Programming
You can edit or add more interests any time.
💬 Help Shape Our Pricing
We're exploring pricing options to make this project sustainable. Take 3 minutes to share what you'd be willing to pay (if anything). Your input guides our future investment.
Help us improve your experience!
This project is on its early stages your feedback can be pivotal on the future of the project.
Let us know what you think about this week's papers and suggestions!
Give Feedback