A Path Less Traveled: Reimagining Software Engineering Automation via a Neurosymbolic Paradigm

Antonio Mastropaolo; Denys Poshyvanyk

REVIEW 4 major objections 5 minor 25 references

A Path Less Traveled: Reimagining Software Engineering Automation via a Neurosymbolic Paradigm

T0 review · 4 major / 5 minor · reviewed 2026-08-16 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This position paper proposes Neurosymbolic Software Engineering (NSE), a paradigm that combines neural learning, symbolic rule-based reasoning, and controlled chaos to make AI-driven software engineering more efficient, interpretable, and…

desk verdict A well-written vision paper whose central novelty—'controlled chaos'—is never defined concretely, so the promised benefits of the NSE paradigm are currently unsupported. read the letter →

arxiv 2505.02275 v1 pith:M5MNUSY6 submitted 2025-05-04 cs.SE

Antonio Mastropaolo , Denys Poshyvanyk This is my paper · ORCID

classification cs.SE

keywords neurosymbolicsoftwareengineeringlargecodemodelsautomationchaostheorycontrolledrandomnessinterpretabilitysustainableAIprogramcomprehension

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This position paper argues that the dominant strategy of making software engineering AI better by scaling up large code models is hitting a wall, and proposes an alternative: Neurosymbolic Software Engineering (NSE), a paradigm that combines neural learning, symbolic rule-based reasoning, and a deliberately injected 'controlled chaos' component. The authors claim this three-part design preserves the flexibility of deep learning while making automated code generation, review, and repair more efficient, interpretable, and robust to uncertainty. The stakes are practical: if the paradigm works, AI-driven software engineering could reduce dependence on hundreds-of-billions-parameter models and massive datasets, and instead use small neural models constrained by formal rules and structured unpredictability. The paper is a conceptual proposal, not an empirical demonstration, so its value lies in laying out a research direction and the open problems along that route.

What carries the argument

The load-bearing mechanism is the triad of Probabilistic Method, Symbolic Method, and Chaos-driven Component, with the last serving as the bridge. The chaos-driven component is defined as variability governed by deterministic rules—sensitive to initial conditions, hence capable of producing drastically different outcomes from tiny changes—which the paper uses to approximate 'true randomness' while retaining control. This structured noise is meant to do two jobs: during training, it simulates out-of-distribution inputs to build robustness; during testing and operation, it explores critical variations in inputs and execution conditions to expose edge cases and vulnerabilities. The symbolic method supplies the correctness and interpretability backbone, and the probabilistic method supplies scale and pattern recognition, so the three are claimed to compensate for one another's weaknesses.

What would settle it

Build an NSE instance that uses a deterministic chaotic map (for example, a logistic map) to perturb inputs to a code-generation or bug-repair model, and compare it against the same pipeline using pseudorandom noise matched in distribution and against plain random testing, on benchmarks measuring correctness, edge-case coverage, and repair success; if the chaotic version is not statistically better on any axis, the paper's central premise falls.

Watch

Extended reading notes

Core claim

The central claim is that software engineering automation should be rebuilt around three interacting components: a probabilistic method (large code models that learn patterns from data), a symbolic method (constraint solvers, rule-based inference, formal verification), and a chaos-driven component that injects structured randomness to model real-world uncertainty. The chaos component is the novel link: because chaotic systems are deterministic yet highly sensitive to initial conditions, they offer a principled middle ground between pure randomness and deterministic logic. During training, controlled chaos can supply structured noise that simulates out-of-distribution data; during testing, targeted chaotic perturbations can reveal edge cases and hidden vulnerabilities that random testing misses. The paper positions NSE as the generalized successor to neurosymbolic program comprehension, and as a response to the projected exhaustion of human-generated training data, often called the 'singularity of automation'.

Load-bearing premise

The whole proposal rests on the claim that a 'controlled chaos' component can stand in for true randomness in software pipelines effectively and efficiently, yet the paper gives no formal definition, experiment, or comparison to existing techniques like fuzzing or chaos engineering.

Editorial extensions

If this is right

If NSE works as proposed, automated software tasks can be made auditable: every suggestion can be checked against explicit rules and formal properties, not just statistical likelihood.
If NSE works as proposed, teams could rely on smaller, specialized neural models supplemented by symbolic constraints, reducing the compute and data footprint of AI coding assistants.
If NSE works as proposed, chaotic perturbation during training should let systems keep performing on out-of-distribution inputs, which is where today's models degrade sharply.
If NSE works as proposed, testing pipelines gain a principled middle ground between random fuzzing and deterministic verification, revealing edge cases that each alone would miss.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

A natural experiment the paper does not run: compare an NSE pipeline whose perturbations come from a chaotic map against the same pipeline using pseudorandom noise; statistical equivalence would show the chaos label is decorative.
The data-scaling argument suggests the same neural-plus-symbolic design could transfer to other constrained domains, such as formal mathematics or contract analysis, but the chaos component would have to be re-tuned for each domain's notion of uncertainty.
The paper describes chaos as a bridge, but a bridge implies feedback: one can imagine closing the loop by letting symbolic verification results modulate the amount of chaotic perturbation, a mechanism the paper leaves implicit.
If chaotic systems are deterministic, the strongest version of NSE would make every run reproducible given initial conditions, which would be a practical advantage over today's stochastic decoding—one the paper does not state.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

This is a position paper, and it reads like one: a clear, readable pitch for combining neural learning, symbolic reasoning, and a 'chaos-driven component' to push back against indiscriminate model scaling. The writing is good, the criticism of the scaling narrative is fair, and the survey of neurosymbolic SE work is useful. I also give credit for listing real open challenges in 3.2.2, including the one that actually sinks this paper: handling randomness effectively. The authors are honest that this is hard, but they don't seem to realize how badly that undermines their own proposal.

The soft spot is the one the stress-test note puts its finger on: 'controlled chaos' is never operationalized. Section 3.1 calls it 'structured randomness i.e., variability governed by deterministic rules'—which is just a description of any seeded pseudorandom generator, not something that needs chaos theory. No equation, no algorithm, no example of what 'chaos' adds over ordinary noise. Every claimed benefit in 3.2.1 (interpretability, scalability, trustworthiness, energy efficiency, adaptivity) is asserted as a consequence of this underspecified mechanism. You could delete the word 'chaos', replace it with 'randomness', and lose nothing. Worse, because the paradigm itself is just a renaming and generalization of the authors' own NsPC framework, the only new ingredient is precisely the one that remains ill-defined.

For a workshop/companion venue, this might be fine as a discussion piece. But as a research contribution it doesn't produce a falsifiable prediction or a concrete artifact. There is no derivation, no data, no benchmark. The paper is not incoherent—it knows what it wants to argue—but the central argument rests on an analogy to chaos theory that is doing no work. I would not cite it as evidence of anything, though it might be worth bringing up in a reading group as an example of how a vision paper can be too vague to be evaluated.

My recommendation: reject for a research venue; accept only if the venue explicitly solicits bold-vision position papers, and then with a request for a concrete instantiation or at least a comparison to standard random-seed baselines. But don't send it to a serious referee expecting a real contribution.

Referee Report

4 major / 5 minor

Summary. This position paper proposes Neurosymbolic Software Engineering (NSE), a paradigm that combines neural probabilistic learning, symbolic (rule-based) reasoning, and a newly introduced 'chaos-driven component' intended to inject controlled randomness into software engineering automation. The paper argues that this hybrid approach offers a more efficient, interpretable, trustworthy, and adaptable alternative to indiscriminate scaling of large code models (LCMs). It describes the three conceptual components, claims a set of opportunities (interpretability, scalability, energy efficiency, context-aware adaptivity), and lists challenges such as handling randomness, encoding symbolic knowledge, generalization, deployment, and explainability. The manuscript contains no formal definitions, equations, experiments, or datasets; it is a high-level vision statement grounded in the authors' prior work on Neurosymbolic Program Comprehension (NsPC).

Significance. If the proposed NSE paradigm were made concrete, it could address real and widely acknowledged limitations of LCM-based software engineering, particularly energy consumption, interpretability, and adaptability. The paper correctly identifies the scaling bottleneck and gives a useful survey of existing neurosymbolic approaches in software engineering. It is honest about open challenges, explicitly noting that handling randomness effectively is a challenge. The central new concept, however, is the chaos-driven component, and the paper does not specify what this component is algorithmically, how it differs from ordinary pseudorandomness or fuzzing, or how its benefits would be measured. As it stands, the paper reads as a promising research agenda rather than a substantiated paradigm claim.

major comments (4)

[Section 3.1] The 'Chaos-driven Component' is the paper's central novelty, but it is never defined with enough precision to be evaluated or falsified. The description 'structured randomness i.e., variability governed by deterministic rules' is satisfied by any pseudorandom number generator, and the paper does not state which chaotic system, which control parameters, or how the chaos is coupled to the neural and symbolic components. Every claimed benefit in Section 3.2.1 (interpretability, scalability, energy efficiency, context-aware adaptivity) is asserted as a consequence of this unspecified mechanism. The paper itself acknowledges in Section 3.2.2 that 'handling randomness effectively' is a challenge, but it offers no control parameters or failure modes for the proposed chaos injection. A formal definition or a concrete instantiation with a minimal ablation is needed for the central claim to be assessable.
[Section 1] The central assertion that chaos theory provides 'an effective and efficient proxy to model true randomness' is presented without argument or comparison to existing techniques such as seeded pseudorandom noise, fuzzing, or chaos engineering. The only cited property of chaotic systems—deterministic but sensitive to initial conditions—is also a property of typical pseudorandom generators. The paper therefore does not currently establish that the chaos-driven component would do anything beyond ordinary randomness, nor does it explain how such a component could be reconciled with the reliability guarantees of the symbolic side. The authors should provide a conceptual or formal argument distinguishing their notion of chaos from standard randomness, or reframe the contribution as a research vision with explicitly open questions.
[Section 2.2 and Section 3.2.2] The paper relies on the authors' prior work on NsPC (Velasco et al.) as the foundation for NSE, calling NSE a 'generalized extension' of that framework. However, no details, empirical results, or known limitations of NsPC are reported here, so the reader cannot judge whether the generalization preserves the properties NSE claims. Given that the validity of the proposed paradigm depends on the validity of its predecessor, the authors should either summarize the evidence supporting NsPC or explicitly state that NSE is an independent proposal whose validation is future work.
[Section 3.2.1] The claimed advantages of NSE—reduced dependence on massive datasets, energy efficiency, robustness against bias, and context-aware adaptation—are stated as facts, but no evidence, even anecdotal or from a toy example, is provided. For a position paper, this would be acceptable if the claims were framed as hypotheses to be tested. Instead, the text speaks in asserted terms ('NSE presents a more energy-efficient alternative', 'NSE reduces the dependence on massive datasets'). The authors should either present a minimal proof-of-concept or explicitly rephrase these statements as testable predictions with proposed evaluation metrics.

minor comments (5)

[Throughout] Several typographical and rendering issues should be fixed: '♂lightbulb' and '/exclamati⌢n-triangle' appear to be corrupted glyphs, 'LMCs' in Section 3.1 should be 'LCMs', 'Velascoet al.' is missing a space, and 'In different research' is awkward phrasing.
[References] References [23] and [24] are the same paper (Watson et al., 'A Systematic Literature Review on the Use of Deep Learning in Software Engineering Research') and should be consolidated; the duplicate entry creates confusion.
[Figure 1] Figure 1 is essentially a high-level diagram with three boxes and an NSE label; it does not convey the architecture or information flow among the probabilistic, symbolic, and chaos-driven components. A more detailed diagram showing interfaces, data flow, and control parameters would be more informative.
[Section 1] The term 'singularity of automation' is introduced without a definition. It is attributed to Velasco et al., but the paper should give a precise meaning or a formal citation to the original use of the term, since it is a key motivation for the proposed paradigm.
[Section 3.2.2] The sentence 'With the possibility to integrate formal verification' should be rephrased to 'With the possibility of integrating formal verification' for grammatical correctness.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: this is a position paper with no derivation chain, fitted parameters, or benchmark predictions to reduce to its inputs.

full rationale

The paper is a position paper: it proposes Neurosymbolic Software Engineering (NSE) as a conceptual combination of probabilistic learning, symbolic reasoning, and controlled chaos. It contains no equations, no fitted parameters, no benchmark results, and no derivation chain that could make a prediction equivalent to an input by construction. The closest candidate is the repeated reference to Velasco et al. [21], the authors' prior NsPC framework, which is described as the foundation for NSE. That is a normal and explicitly acknowledged extension of prior work; the paper does not use NsPC to validate NSE's claims, and it frames NSE as a 'generalized extension' rather than as a result inferred from NsPC. The 'controlled chaos' component is under-specified, since the paper does not define an algorithm or equation for it, and its characterization as 'structured randomness, i.e., variability governed by deterministic rules' is vague. Under-specification is a scientific weakness, but it is not circularity: no output quantity is defined in terms of itself, and no claimed result is forced by the paper's own definitions. The paper also self-identifies the main open problems in Section 3.2.2, including handling randomness effectively, the absence of frameworks and benchmarks, and generalization challenges, which further confirms that the claims are proposals rather than closed derivations. Concerns about empirical support, falsifiability, or the novelty of 'controlled chaos' belong to correctness risk, not to circularity. I therefore find no circular step.

Assumptions & free parameters 0 free parameters · 4 assumptions · 2 invented entities

The paper contributes a conceptual architecture, not a derivation or experiment. Its claims rest on assumptions about chaos theory, symbolic integration, and LLM scaling limits that are asserted from prior work or common sense. No free parameters are fitted, and the invented components are described without enough specificity to evaluate independently.

assumptions (4)

ad hoc to paper Chaos theory provides an effective and efficient proxy for true randomness in software engineering automation pipelines.
Asserted in Section 1 without supporting evidence or formal justification.
domain assumption Symbolic reasoning and neural learning can be integrated into a unified pipeline without degrading performance to unacceptable levels.
Stated as an opportunity in Section 3.2.1, and acknowledged as a challenge in Section 3.2.2, but no mechanism is provided to guarantee feasibility.
domain assumption The scaling limits of LLMs (the 'singularity of automation') motivate the need for alternative paradigms.
Based on Villalobos et al. [22] and treated as an accepted premise, though the argument's strength is debatable.
domain assumption The Neurosymbolic Program Comprehension (NsPC) framework by Velasco et al. is a valid foundation for NSE.
The paper extends NsPC, whose authors include two of the current authors, but NsPC itself is not independently validated in this paper.

invented entities (2)

Chaos-driven Component
purpose: Injects controlled randomness into the neurosymbolic pipeline to bridge neural and symbolic reasoning and simulate real-world uncertainty.
The component is described conceptually in Section 3.1 but no algorithm, mathematical formulation, or test is provided. No independent falsifiable handle exists.
Neurosymbolic Software Engineering (NSE) as a named paradigm
purpose: Unifies probabilistic methods, symbolic reasoning, and chaos into a single paradigm for all software engineering tasks.
The paradigm is a conceptual proposal without implementation or benchmarks. It is a new label for a combination of known ideas, not a new entity with independent evidence.

how reviews work

0 comments

Cite this review

Pith. "Pith review of A Path Less Traveled: Reimagining Software Engineering Automation via a Neurosymbolic Paradigm." pith.science (2026). https://pith.science/paper/M5MNUSY6

@misc{pith2026250502275,
  author       = {Pith},
  title        = {Pith review of: A Path Less Traveled: Reimagining Software Engineering Automation via a Neurosymbolic Paradigm},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/M5MNUSY6}},
  note         = {Machine review of arXiv:2505.02275}
}

read the original abstract

The emergence of Large Code Models (LCMs) has transformed software engineering (SE) automation, driving significant advancements in tasks such as code generation, source code documentation, code review, and bug fixing. However, these advancements come with trade-offs: achieving high performance often entails exponential computational costs, reduced interpretability, and an increasing dependence on data-intensive models with hundreds of billions of parameters. In this paper, we propose Neurosymbolic Software Engineering, in short NSE, as a promising paradigm combining neural learning with symbolic (rule-based) reasoning, while strategically introducing a controlled source of chaos to simulate the complex dynamics of real-world software systems. This hybrid methodology aims to enhance efficiency, reliability, and transparency in AI-driven software engineering while introducing controlled randomness to adapt to evolving requirements, unpredictable system behaviors, and non-deterministic execution environments. By redefining the core principles of AI-driven software engineering automation, NSE lays the groundwork for solutions that are more adaptable, transparent, and closely aligned with the evolving demands of modern software development practices.

Figures

Figures reproduced from arXiv: 2505.02275 by the authors.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

25 extracted references · 10 canonical work pages

[1]

[n. d.]. Amazon CodeWhisperer. https://aws.amazon.com/codewhisperer/. Ac- cessed: 2024-03-10

work page 2024
[2]

[n. d.]. ChatGPT https://openai.com/blog/chatgpt

work page
[3]

[n. d.]. GitHub Copilot – Your AI pair programmer. https://github.com/features/ copilot/. Accessed: 2024-03-10

work page 2024
[4]

Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Floren- cia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. 2023. Gpt-4 technical report. arXiv preprint arXiv:2303.08774 (2023)

arXiv 2023
[5]

Miltiadis Allamanis, Pankajan Chanthirasegaran, Pushmeet Kohli, and Charles Sutton. 2017. Learning continuous semantic representations of symbolic expres- sions. In Proceedings of the 34th International Conference on Machine Learning - Volume 70 (Sydney, NSW, Australia)(ICML’17). JMLR.org, 80–88

work page 2017
[6]

Anthropic. n.d.. The Claude 3 Model Family: Opus, Sonnet, Haiku. https: //www-cdn.anthropic.com/de8ba9b01c9ab7cbabf5c33b80b7bbc618857627/ Model_Card_Claude_3.pdf. Accessed: 2025-02-26

work page 2025
[7]

Shushan Arakelyan, Anna Hakhverdyan, Miltiadis Allamanis, Luis Garcia, Christophe Hauser, and Xiang Ren. 2024. NS3: neuro-symbolic semantic code search. In Proceedings of the 36th International Conference on Neural Information Processing Systems (New Orleans, LA, USA) (NIPS ’22). Curran Associates Inc., Red Hook, NY, USA, Article 761, 16 pages

work page 2024
[8]

DeepSeek-AI, Qihao Zhu, Daya Guo, Zhihong Shao, Dejian Yang, Peiyi Wang, Runxin Xu, Y. Wu, Yukun Li, Huazuo Gao, Shirong Ma, Wangding Zeng, Xiao Bi, Zihui Gu, Hanwei Xu, Damai Dai, Kai Dong, Liyue Zhang, Yishi Piao, Zhibin Gou, Zhenda Xie, Zhewen Hao, Bingxuan Wang, Junxiao Song, Deli Chen, Xin Xie, Kang Guan, Yuxiang You, Aixin Liu, Qiushi Du, Wenjun Gao...

arXiv 2024

Show all 25 references

[9]

Jacob Devlin, Jonathan Uesato, Rishabh Singh, and Pushmeet Kohli. 2017. Se- mantic Code Repair using Neuro-Symbolic Transformation Networks. http: //arxiv.org/abs/1710.11054 arXiv:1710.11054

2017 arXiv
[10]

Daniel Fried, Armen Aghajanyan, Jessy Lin, Sida Wang, Eric Wallace, Freda Shi, Ruiqi Zhong, Wen-tau Yih, Luke Zettlemoyer, and Mike Lewis. 2022. InCoder: A Generative Model for Code Infilling and Synthesis. CoRR abs/2204.05999 (2022). doi:10.48550/arXiv.2204.05999

2022 doi arXiv
[11]

James Gleick. 2008. Chaos: Making a new science . Penguin

2008
[12]

Xinyi Hou, Yanjie Zhao, Yue Liu, Zhou Yang, Kailong Wang, Li Li, Xiapu Luo, David Lo, John Grundy, and Haoyu Wang. 2024. Large language models for software engineering: A systematic literature review. ACM Transactions on Software Engineering and Methodology 33, 8 (2024), 1–79

2024
[13]

Yaojie Hu, Xingjian Shi, Qiang Zhou, and Lee Pike. 2022. Fix Bugs with Trans- former through a Neural-Symbolic Edit Grammar. doi:10.48550/arXiv.2204.06643 arXiv:2204.06643

2022 doi arXiv
[14]

Prithwish Jana, Piyush Jha, Haoyang Ju, Gautham Kishore, Aryan Mahajan, and Vijay Ganesh. 2024. CoTran: An LLM-based Code Translator using Reinforcement Learning with Feedback from Compiler and Symbolic Execution. doi:10.48550/ arXiv.2306.06755 arXiv:2306.06755

2024 doi arXiv
[15]

Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Cheng- gang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, et al. 2024. Deepseek-v3 technical report. arXiv preprint arXiv:2412.19437 (2024)

2024 arXiv
[16]

Anton Lozhkov, Raymond Li, Loubna Ben Allal, Federico Cassano, Joel Lamy- Poirier, Nouamane Tazi, Ao Tang, Dmytro Pykhtar, Jiawei Liu, Yuxiang Wei, et al. 2024. Starcoder 2 and the stack v2: The next generation. arXiv preprint arXiv:2402.19173 (2024)

2024 arXiv
[17]

Emilio Parisotto, Abdel-rahman Mohamed, Rishabh Singh, Lihong Li, Dengyong Zhou, and Pushmeet Kohli. 2016. Neuro-Symbolic Program Synthesis. doi:10. 48550/arXiv.1611.01855 arXiv:1611.01855

2016 doi arXiv
[18]

Henrijs Princis, Cristina David, and Alan Mycroft. 2024. Enhancing SQL Query Generation with Neurosymbolic Reasoning. doi:10.48550/arXiv.2408.13888 arXiv:2408.13888

2024 doi arXiv
[19]

Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiao- qing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, et al. 2023. Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950 (2023)

2023 arXiv
[20]

Jieke Shi, Zhou Yang, and David Lo. 2024. Efficient and green large language models for software engineering: Vision and the road ahead. ACM Transactions on Software Engineering and Methodology (2024)

2024
[21]

Alejandro Velasco, Aya Garryyeva, David N Palacio, Antonio Mastropaolo, and Denys Poshyvanyk. 2025. Toward Neurosymbolic Program Comprehension. arXiv preprint arXiv:2502.01806 (2025)

2025 arXiv
[22]

Pablo Villalobos, Anson Ho, Jaime Sevilla, Tamay Besiroglu, Lennart Heim, and Marius Hobbhahn. 2024. Will we run out of data? Limits of LLM scaling based on human-generated data. doi:10.48550/arXiv.2211.04325

2024 doi arXiv
[23]

Cody Watson, Nathan Cooper, David Nader Palacio, Kevin Moran, and Denys Poshyvanyk. 2022. A Systematic Literature Review on the Use of Deep Learning in Software Engineering Research. ACM Trans. Softw. Eng. Methodol. 31, 2, Article 32 (March 2022), 58 pages. doi:10.1145/3485275

2022 doi
[24]

Cody Watson, Nathan Cooper, David Nader Palacio, Kevin Moran, and Denys Poshyvanyk. 2022. A Systematic Literature Review on the Use of Deep Learning in Software Engineering Research. ACM Transactions on Software Engineering and Methodology, TOSEM 31, 2 (2022), 1–58

2022
[25]

Min Xue, Artur Andrzejak, and Marla Leuther. 2024. An interpretable error correction method for enhancing code-to-code translation. In The Twelfth Inter- national Conference on Learning Representations . https://openreview.net/forum? id=fVxIEHGnVT

2024

Pith tools

Reviewed August 16, 2026 · model on record in the stance chip above.

[1] [1]

[n. d.]. Amazon CodeWhisperer. https://aws.amazon.com/codewhisperer/. Ac- cessed: 2024-03-10

work page 2024

[2] [2]

[n. d.]. ChatGPT https://openai.com/blog/chatgpt

work page

[3] [3]

[n. d.]. GitHub Copilot – Your AI pair programmer. https://github.com/features/ copilot/. Accessed: 2024-03-10

work page 2024

[4] [4]

Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Floren- cia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. 2023. Gpt-4 technical report. arXiv preprint arXiv:2303.08774 (2023)

arXiv 2023

[5] [5]

Miltiadis Allamanis, Pankajan Chanthirasegaran, Pushmeet Kohli, and Charles Sutton. 2017. Learning continuous semantic representations of symbolic expres- sions. In Proceedings of the 34th International Conference on Machine Learning - Volume 70 (Sydney, NSW, Australia)(ICML’17). JMLR.org, 80–88

work page 2017

[6] [6]

Anthropic. n.d.. The Claude 3 Model Family: Opus, Sonnet, Haiku. https: //www-cdn.anthropic.com/de8ba9b01c9ab7cbabf5c33b80b7bbc618857627/ Model_Card_Claude_3.pdf. Accessed: 2025-02-26

work page 2025

[7] [7]

Shushan Arakelyan, Anna Hakhverdyan, Miltiadis Allamanis, Luis Garcia, Christophe Hauser, and Xiang Ren. 2024. NS3: neuro-symbolic semantic code search. In Proceedings of the 36th International Conference on Neural Information Processing Systems (New Orleans, LA, USA) (NIPS ’22). Curran Associates Inc., Red Hook, NY, USA, Article 761, 16 pages

work page 2024

[8] [8]

DeepSeek-AI, Qihao Zhu, Daya Guo, Zhihong Shao, Dejian Yang, Peiyi Wang, Runxin Xu, Y. Wu, Yukun Li, Huazuo Gao, Shirong Ma, Wangding Zeng, Xiao Bi, Zihui Gu, Hanwei Xu, Damai Dai, Kai Dong, Liyue Zhang, Yishi Piao, Zhibin Gou, Zhenda Xie, Zhewen Hao, Bingxuan Wang, Junxiao Song, Deli Chen, Xin Xie, Kang Guan, Yuxiang You, Aixin Liu, Qiushi Du, Wenjun Gao...

arXiv 2024