Pith. sign in

REVIEW 3 major objections 4 minor 34 references

This paper proposes a risk-adaptive governance rule for AI-assisted code review and shows, via simulation, that applying evidence-based controls only to risky changes cuts governance cost by about 38% while accepting lower trust and detecti

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

T0 review · deepseek-v4-flash

2026-08-01 09:42 UTC pith:RULBOOSZ

load-bearing objection The paper is a clearly written, honest framework proposal, but its central empirical claim—that risk-adaptive targeting works—is untested because events are independent of the risk signal. the 3 major comments →

arxiv 2607.27310 v1 pith:RULBOOSZ submitted 2026-07-29 cs.SE

TrustChain-Review: A Risk-Adaptive Blockchain and Game-Theoretic Framework for Trustworthy AI-Assisted Code Review

Mohammad Naserameri This is my paper
classification cs.SE
keywords AI-assisted code reviewblockchain evidencegame theoryrisk-adaptive governancereputation systemscode review trustincentive mechanismscontrolled simulation
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

TrustChain-Review tries to establish that trustworthy code review in AI-assisted development should be governed adaptively: cheap basic review for routine changes, richer evidence-based review only when the change's risk justifies the extra cost. It bundles a blockchain evidence layer, a three-player game (developer, reviewer, platform), and a threshold rule that converts a patch-length risk score into a governance choice. In a simulation calibrated to a 328,340-instance code-review dataset, the full-evidence configuration gives the best reputation accuracy (0.797) and detection rates but the highest cost (0.328), while the risk-adaptive configuration cuts cost to 0.202 and nearly doubles cost-efficiency (2.509 vs 1.465) at lower trust and detection. The paper's message is that no single governance setting dominates; the threshold should be set by project criticality and loss potential.

Core claim

On the paper's own terms, the central finding is a quantified trade-off: uniform evidence-based governance produces the strongest reputation, trust, and unreliable-review detection, while a threshold-governed variant delivers most of the benefit at meaningfully lower cost. The risk score is computed from the clipped patch length via r = log(1+p)/log(1+p_max), and evidence-based governance is applied when r exceeds a threshold (baseline 0.50). In 30 paired simulation runs, full evidence achieved reputation accuracy 0.797 ± 0.001, malicious-review detection 0.790 ± 0.035, and governance cost 0.328; risk-adaptive achieved 0.694 ± 0.002, 0.629 ± 0.045, and cost 0.202, improving cost-efficiency f

What carries the argument

The load-bearing mechanism is the risk-triggered governance rule and its threshold r*. A pre-review risk score r_t is computed solely from the clipped patch length, and the platform selects evidence-based governance when r_t > r* and basic governance otherwise. The threshold is derived from a platform-utility comparison: evidence-based governance is chosen when the expected reduction in loss from undetected harmful changes, plus quality and trust gains, exceeds the added governance cost. The accompanying three-player game (developer, reviewer, platform) supplies incentive-compatibility conditions that, if satisfied, make the trustworthy strategy profile jointly preferred. Blockchain appears

Load-bearing premise

The evaluation's transfer to real AI-assisted code review depends on the assumption that the controlled simulation variables—malicious-review probability 0.15, superficial-review probability 0.20, governance costs, detection effectiveness, and the linear benefit weights—and the use of clipped patch length as a pre-review risk signal approximate real conditions; the dataset itself does not even identify AI-assisted changes.

What would settle it

Collect post-merge defect or rollback outcomes for a real code-review platform using the same risk rule, and check whether changes with risk score below the 0.50 threshold produce defects at a rate comparable to above-threshold changes; if they do, the patch-length risk proxy and the threshold rule fail to separate risky from safe changes.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • If the framework's claims hold, code-review platforms can reduce governance overhead by roughly 38% while retaining most trust and detection performance by switching to evidence-based review only for high-risk changes.
  • Full-evidence governance is the paper's recommended setting for high-risk or audit-sensitive repositories; routine or low-risk contributions do not justify the extra cost.
  • Reputation accuracy, trust convergence, and detection rates fall when evidence-based governance is applied selectively, so the threshold directly trades protection against cost.
  • Blockchain traceability alone does not produce the best outcomes; the results show that incentives and evidence assessment must accompany it.
  • The risk score can be refined with richer signals (criticality, subsystem, test coverage, vulnerability findings) in deployment, since patch length is only a baseline proxy.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • An implicit consequence is that the same framework could be tuned per project by estimating the threshold from real loss data; a project facing high failure costs would adopt a lower r*, and a cost-sensitive project a higher one.
  • The patch-length risk proxy may under-trigger for small but security-critical changes; a natural extension is to combine patch length with impact or severity metadata so the adaptive rule responds to semantic risk rather than size alone.
  • The simulation's paired design suggests that comparing configurations on a real repository, where post-merge defects and rollbacks are observed, would provide a direct test of whether the risk-adaptive regime actually prevents harmful merges.
  • The game-theoretic incentive conditions, though not used in the simulation, point toward a reinforcement-learning extension in which the platform adjusts penalties and audit rates as evidence accumulates—an avenue the paper explicitly leaves open.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 4 minor

Summary. The paper proposes TrustChain-Review, a framework combining blockchain evidence, a three-player game-theoretic model, and a threshold rule that switches between basic and evidence-based governance. A paired simulation calibrated with the Diff Quality Estimation dataset is used to compare six governance configurations. Full-evidence governance yields the highest reputation, trust, and detection metrics but the highest cost; risk-adaptive governance lowers cost and improves cost-efficiency at the cost of lower trust and detection. The manuscript states that the game-theoretic equations and threshold formula are not used to compute the Table 10 results.

Significance. If the adaptive mechanism were validated, the framework would address a real integration gap among evidence, incentives, and governance. The paper is commendably transparent: it ships a reproducibility package, uses paired seeds, and explicitly lists limitations. However, the evaluation does not test the adaptive rule: the simulated events are independent of the risk score, and the reported risk-adaptive metrics are exact convex combinations of two fixed configurations. The AI-assistance motivation is also not present in the dataset. The paper is therefore best read as a well-documented proposal whose central empirical claim remains unsubstantiated.

major comments (3)
  1. [§6.3, Algorithm 1, Table 10] The risk-adaptive configuration is an arithmetic re-weighting of the full-evidence and basic configurations. At r*=0.50, evidence-based governance is selected in about 39.4% of rounds. Since M_t and S_t are generated with fixed probabilities independent of r_t (Algorithm 1, steps 5-8), the expected detection rates are 0.394 * full + 0.606 * basic. Using Table 10, mal. det. = 0.394*0.790 + 0.606*0.519 = 0.629; sup. det. = 0.394*0.733 + 0.606*0.526 = 0.608; rep. acc. = 0.394*0.797 + 0.606*0.627 = 0.694; cost = 0.394*0.328 + 0.606*0.120 = 0.202. A random rule selecting evidence-based governance with probability 0.394 would produce the same expectation. Without a random-selection control or a conditional analysis within risk strata, the paper does not show that the risk signal adds value.
  2. [§5.9] The displayed threshold equation is not the solution to the inequality above it. From r * l * (p_B - p_E) + G_Q + G_T + G_rep >= C_E - C_B, solving for r gives r* = (C_E - C_B - G_Q - G_T - G_rep) / (l * (p_B - p_E)) when the denominator is positive. The displayed formula is dimensionally inconsistent and cannot be derived from the preceding inequality. Moreover, the text immediately states that r* = 0.50 is a predefined experimental setting and that the equation is not used in the simulation. The formal rule is therefore disconnected from the empirical headline; the derivation should be corrected or explicitly labeled as illustrative only.
  3. [§7.11, §1, Conclusion] The evaluation uses a dataset that does not identify AI-assisted contributions; §7.11 explicitly concedes that AI assistance is neither observed nor manipulated. The title, abstract, and conclusion nevertheless frame the contribution as a framework for AI-assisted code review. As it stands, the empirical study supports claims about a generic code-review governance mechanism, not about AI-assisted review specifically. Either reframe the paper's contribution as a general code-review governance framework or add an evaluation condition that varies AI assistance (for example, the fraction of AI-generated patches) so that the motivating scenario is actually tested.
minor comments (4)
  1. [Section headings] There are two sections numbered 4: '4. TrustChain-Review Architecture' and '4. Game-Theoretic Formulation' (the latter is followed by 5.1). Renumber the second to 5.
  2. [Algorithm 1] Line 23 shows '23: 23:' — a duplicated line number. Also, '23: Compute the governance-benefit score ...' is actually step 23, so this is a typographical error in the algorithm listing.
  3. [Equations and notation] Several equations use garbled Unicode symbols, e.g., 'p_E/p_B' rendering and the r* formula in §5.9. The typesetting should be cleaned up with proper math notation.
  4. [§5.6] The paper correctly notes that the incentive-compatibility conditions do not prove existence or uniqueness of a Nash equilibrium. This is a useful limitation, but it should also appear in the main text near the equilibrium discussion, not only in a final sentence.

Circularity Check

1 steps flagged

Risk-adaptive headline results are the arithmetic mixture of the two hand-set governance configurations; the risk signal itself is never tested.

specific steps
  1. self definitional [Section 8 / Table 10; threshold selection in Section 5.9 and Algorithm 1]
    "Relative to full evidence, its mean governance cost decreases from 0.328 to 0.202, a reduction of approximately 38.4%, while cost-efficiency increases from 1.465 to 2.509, an improvement of approximately 71.3%. ... At the baseline threshold (r*=0.50), the selection rate decreases to approximately 39.4%, governance cost decreases to 0.202, and cost-efficiency increases to 2.509."

    The risk-adaptive configuration is defined as choosing full-evidence (cost 0.328) when r_t>0.50 and basic (cost 0.120) otherwise. With the reported 39.4% selection rate, cost = 0.394*0.328 + 0.606*0.120 ≈ 0.202, and malicious detection = 0.394*0.790 + 0.606*0.519 ≈ 0.626, matching Table 10. Because Algorithm 1 generates M_t/S_t independently of r_t, a 39.4% random selector would produce the same numbers. The 'lower cost / higher cost-efficiency' finding is therefore a restatement of the hand-set threshold and per-configuration costs, not an estimated benefit of risk-based allocation.

full rationale

The paper is transparent about many of its moves: it repeatedly states that the game-theoretic equations are not used to calculate the simulation results, and that r*=0.50 is a predefined experimental setting rather than a derived optimum. The self-citation ([13]) is related work and not load-bearing. The dataset is external and supplies the patch-length distribution, so the simulation is not entirely self-referential. However, the central empirical claim about the risk-adaptive configuration—that it improves cost-efficiency and lowers governance cost by selectively applying evidence-based governance—is forced by construction. The reported cost and detection figures are weighted averages of the basic and full-evidence configurations using the 39.4% selection rate. Since the malicious/superficial events are generated independently of the risk score, the same figures would arise from a random selector with the same selection rate. This makes the risk-adaptive 'advantage' an arithmetic consequence of the chosen threshold and fixed per-configuration parameters, not evidence that the risk signal adds value. This is partial circularity: the headline result reduces to the definition of the mixture, even though the underlying simulation is reproducible and the limitation is partially acknowledged.

Axiom & Free-Parameter Ledger

7 free parameters · 7 axioms · 0 invented entities

The central simulation results depend on a set of hand-set parameters (costs, event probabilities, threshold, benefit weights, detection probabilities) plus assumptions that the dataset is a valid proxy and that evidence-based governance is more effective. The game-theoretic equations are not used numerically, so they contribute theory but not evidence.

free parameters (7)
  • Baseline governance threshold r* = 0.50 (sensitivity 0.44-0.54)
    Predefined experimental setting, not derived from the Section 5.9 cost-benefit quantities; controls the fraction of evidence-based rounds (39.4% at 0.50).
  • Malicious-review event probability P(M_t=1) = 0.15
    Controlled simulation variable; the dataset does not record malicious reviews.
  • Superficial-review event probability P(S_t=1) = 0.20
    Controlled simulation variable; the dataset does not record superficial reviews.
  • Governance cost per configuration = 0.100, 0.120, 0.240, 0.190, 0.328; basic 0.120
    Hand-set cost values for simple, centralized, blockchain-only, static, and full-evidence configurations; these drive the cost-reduction result.
  • Governance-benefit score weights = 0.30, 0.25, 0.20, 0.15 (sum 0.90)
    Fixed weights defining the operational benefit score; not justified by data or theory.
  • Per-configuration detection probabilities for malicious/superficial reviews = Not reported explicitly; implied by Table 10
    Simulated detection outcomes depend on unstated configuration-specific probabilities controlled by the authors, not estimated from the dataset.
  • Reputation/trust update parameters = Not reported
    The equations in Section 5.7 are stated not to be used; the simulation's reputation and trust dynamics require additional update parameters not specified in the text, only in the reproducibility package.
axioms (7)
  • domain assumption Actors are rational or boundedly rational and respond to incentives
    Section 3.6 A3; necessary for the game-theoretic incentive interpretation.
  • domain assumption The platform can collect repository, test, and static-analysis evidence
    Section 3.6 A1; needed for the evidence layer to function.
  • ad hoc to paper Evidence-based governance has strictly better detection: 0 <= p_E < p_B <= 1
    Section 5.9; this assumption guarantees evidence-based governance is more effective at avoiding harmful outcomes and is central to the threshold result.
  • ad hoc to paper Clipped patch length is a usable pre-review proxy for contribution risk
    Section 6.3; the risk score r_t is a log transform of clipped patch length. The paper acknowledges this is only a proxy and does not capture semantic complexity.
  • ad hoc to paper The linear governance-benefit score with fixed weights captures platform utility
    Section 6.5; the Phi score and weights are chosen without external justification.
  • ad hoc to paper Controlled malicious/superficial event probabilities and costs represent realistic reviewer environments
    Section 7.4; these variables are not observed in the dataset, and all results depend on them.
  • domain assumption The Diff Quality Estimation dataset is relevant to AI-assisted code review
    Section 7.11; the dataset does not identify AI-assisted changes, so transfer to AI-assisted development is assumed.

pith-pipeline@v1.3.0-daily-deepseek · 18411 in / 17070 out tokens · 134838 ms · 2026-08-01T09:42:25.388039+00:00 · methodology

0 comments
read the original abstract

Context: AI-assisted software development can speed up coding and review, but it also makes accountability harder to establish. Developers may submit insufficiently verified code, reviewers may approve changes with limited inspection, and centralized reputation records may be difficult to audit. Objectives: This study introduces TrustChain-Review, a framework that combines verifiable evidence, strategic incentives, and risk-sensitive governance to support more trustworthy code review. Methods: The framework includes a blockchain-based evidence layer, a three-player game-theoretic model for developers, reviewers, and the platform, and a rule that applies stronger governance when the expected benefit justifies its cost. The evaluation uses a controlled simulation calibrated with the Diff Quality Estimation dataset. Six governance configurations are compared over 30 independent runs using reputation accuracy, trust convergence, malicious-review detection, superficial-review detection, net platform utility, governance cost, and cost-efficiency. Results: The full-evidence configuration produces the strongest reputation, trust, and detection results, but it also has the highest governance cost. The risk-adaptive configuration lowers this cost and improves cost-efficiency by applying stronger controls selectively, although its trust and detection results are lower than those of the full-evidence setting. Conclusion: Strong evidence-based governance is most appropriate for high-risk or audit-sensitive changes. For routine or lower-risk contributions, selective governance offers a more practical balance between trustworthiness and operational cost.

Figures

Figures reproduced from arXiv: 2607.27310 by Mohammad Naserameri.

Figure 1
Figure 1. Figure 1: Mean trust-convergence trajectories across 30 independent simulation runs. [PITH_FULL_IMAGE:figures/full_fig_p021_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Mean malicious and superficial review detection rates across 30 independent simulation runs; error bars indicate standard deviation. [PITH_FULL_IMAGE:figures/full_fig_p021_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Sensitivity of evidence-governance selection rate, governance cost, and cost-efficiency to the risk threshold ( [PITH_FULL_IMAGE:figures/full_fig_p022_3.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

34 extracted references · 6 canonical work pages

  1. [1]

    Introduction AI-assisted software development is changing how software is designed, implemented, reviewed, and maintained [1], [2]. Coding assistants, large language models, automated testing tools, and intelligent review systems can help developers generate code, explain program behaviour, detect defects, and support maintenance tasks. These tools may im...

  2. [2]

    We formulate the trust problem in AI-assisted code review as a strategic multi-agent interaction among developers, reviewers, and platform operators

  3. [3]

    We propose a blockchain-enabled evidence layer for recording or referencing review activities, dataset- observed review evidence, code-change metadata, and reputation-relevant events in a tamper-resistant and auditable manner, while treating test outcomes, vulnerability signals, and post-merge defects as future deployment-level evidence sources

  4. [4]

    We formulate a three-player game-theoretic incentive model that connects developer effort, reviewer reliability, reputation effects, contribution risk, and platform governance cost

  5. [5]

    We introduce a risk-triggered governance rule that determines when the expected trust, auditability, and risk- reduction benefits of evidence-based review outweigh its additional operational cost

  6. [6]

    We evaluate the framework through an empirically calibrated controlled simulation and quantify the trade- off between reputation reliability, malicious and superficial review detection, platform utility, and governance cost across multiple baseline settings

  7. [7]

    AI-Assisted Software Development and Code Review AI-assisted development tools now support code generation, repair, testing, explanation, and review [15]

    Related Work 2.1. AI-Assisted Software Development and Code Review AI-assisted development tools now support code generation, repair, testing, explanation, and review [15]. Although they can shorten development time, their outputs may still contain hidden defects, insecure dependencies, weak design choices, or code that does not fit project requirements [...

  8. [8]

    System Setting The system consists of developers, reviewers, and a repository platform

    Problem Definition and Threat Model 3.1. System Setting The system consists of developers, reviewers, and a repository platform. Developers submit code changes that may be written manually or produced with the support of coding tools [15]. Reviewers inspect these changes, while the platform manages assignments, review policies, reputation records, and inc...

  9. [9]

    TrustChain-Review Architecture TrustChain-Review connects five layers: data collection, blockchain evidence, reputation, strategic incentives, and adaptive governance. 4.1. Layer 1: Data and Event Collection Layer This layer collects contribution and review evidence. The current study uses patch, oldf, msg, y, proj, lang, and id/idx from the Diff Quality ...

  10. [10]

    Game-Theoretic Formulation The game-theoretic model represents the choices of developers, reviewers, and the platform and identifies the conditions under which careful contribution, reliable review, and evidence-based governance are preferred to their lower-effort alternatives [8], [9]. 5.1. Players The game includes three players. Developer. The develope...

  11. [11]

    The current study evaluates reproducible rules rather than a trained learning policy

    Adaptive Governance Mechanism The game-theoretic model defines incentive conditions, while the governance mechanism selects a predefined configuration according to observable contribution risk. The current study evaluates reproducible rules rather than a trained learning policy. 6.1. Governance Objective The objective is to improve review reliability, tru...

  12. [12]

    Empirical Dataset and Experimental Design The evaluation has two stages. First, the Diff Quality Estimation dataset is analyzed to extract observable code-review characteristics, including patch size, review-comment availability, review-need labels, project context, language metadata, and instance identifiers. Second, these characteristics are used to cal...

  13. [13]

    Infusion of Blockchain to Establish Trustworthiness in AI Supported Software Evolution: A Systematic Literature Review,

    M. Naserameri and J. Rilling, “Infusion of Blockchain to Establish Trustworthiness in AI Supported Software Evolution: A Systematic Literature Review,” arXiv.org, 2026. https://arxiv.org/abs/2601.20918 (accessed Jun. 05, 2026)

    arXiv 2026

  14. [14]

    The environment uses the empirical calibration and controlled variables defined in Section 7

    Simulation Results and Analysis Table 10 reports the mean and standard deviation of the evaluation metrics across 30 paired simulation runs. The environment uses the empirical calibration and controlled variables defined in Section 7. No AI-assistance ratio is varied, and no learned governance policy, reviewer assignment, or independently optimized reward...

  15. [15]

    Discussion and Research Implications 9.1. Interpretation of Empirical and Simulation Findings The empirical variables support reproducible calibration but remain proxies rather than direct measures of semantic correctness, security severity, reviewer competence, or software criticality. Full-evidence governance provides the strongest trust and unreliable-...

  16. [16]

    The framework connects auditable evidence, reputation, strategic incentives, and threshold-based selection between basic and evidence-based governance

    Conclusion This study presented TrustChain-Review, a blockchain-enabled, game-theoretic, and risk-adaptive framework for trustworthy AI-assisted code review. The framework connects auditable evidence, reputation, strategic incentives, and threshold-based selection between basic and evidence-based governance. The empirical analysis of 328,340 dataset recor...

  17. [17]

    Large Language Models for Software Engineering: Survey and Open Problems,

    A. Fan et al., “Large Language Models for Software Engineering: Survey and Open Problems,” May 2023, doi: https://doi.org/10.1109/icse-fose59343.2023.00008

    arXiv 2023

  18. [18]

    A Survey on Large Language Models for Code Generation,

    J. Jiang, F. Wang, J. Shen, S. Kim, and S. Kim, “A Survey on Large Language Models for Code Generation,” arXiv.org, 2024, doi: https://doi.org/10.1145/3747588

    doi:10.1145/3747588 2024

  19. [19]

    AI Code Generation and the Rise of Design Flaws,

    S. Gupta and A. Mehta, “AI Code Generation and the Rise of Design Flaws,” International journal of latest research in engineering and technology., vol. 11, no. 6, pp. 16–25, Jul. 2025, doi: https://doi.org/10.56581/ijlret.11.06.16-25

    work page doi:10.56581/ijlret.11.06.16-25 2025

  20. [20]

    Four eyes are better than two: On the impact of code reviews on software quality,

    G. Bavota and B. Russo, “Four eyes are better than two: On the impact of code reviews on software quality,” IEEE Xplore, Sep. 01, 2015. https://ieeexplore.ieee.org/document/7332454

    arXiv 2015

  21. [21]

    Search-Based Peer Reviewers Recommendation in Modern Code Review,

    A. Ouni, Raula Gaikovina Kula, and K. Inoue, “Search-Based Peer Reviewers Recommendation in Modern Code Review,” Oct. 2016, doi: https://doi.org/10.1109/icsme.2016.65

    work page doi:10.1109/icsme.2016.65 2016

  22. [22]

    An Incentive and Reputation Mechanism Based on Blockchain for Crowd Sensing Network,

    Z. Noshad et al., “An Incentive and Reputation Mechanism Based on Blockchain for Crowd Sensing Network,” Journal of Sensors, vol. 2021, p. e1798256, Jul. 2021, doi: https://doi.org/10.1155/2021/1798256

    work page doi:10.1155/2021/1798256 2021

  23. [23]

    A survey of trust and reputation systems for online service provision,

    A. Jøsang, R. Ismail, and C. Boyd, “A survey of trust and reputation systems for online service provision,” Decision Support Systems, vol. 43, no. 2, pp. 618–644, Mar. 2007, doi: https://doi.org/10.1016/j.dss.2005.05.019

    doi:10.1016/j.dss.2005.05.019 2007

  24. [24]

    Recent developments of game theory and reinforcement learning approaches: A systematic review,

    G. Jain, A. Kumar, and Shahid Ahmad Bhat, “Recent developments of game theory and reinforcement learning approaches: A systematic review,” IEEE access , pp. 1–1, Jan. 2024, doi: https://doi.org/10.1109/access.2024.3352749

    arXiv 2024

  25. [25]

    Computational Game Theory and Multi-Agent Systems: Strategic Decision-Making in AI Ecosystems,

    R. Reynold, “Computational Game Theory and Multi-Agent Systems: Strategic Decision-Making in AI Ecosystems,” International Journal of Emerging Trends in Computer Science and Information Technology, vol. 3, no. 1, pp. 1–11, 2022, doi: https://doi.org/10.63282/3050-9246.ijetcsit-v3i2p101

    work page doi:10.63282/3050-9246.ijetcsit-v3i2p101 2022

  26. [26]

    A Comprehensive Review of Reinforcement Learning,

    Ramesh Ghimire and D. Kumar, “A Comprehensive Review of Reinforcement Learning,” Mid-West University Journal of Engineering & Innovation, vol. 1, pp. 1–13, Dec. 2025, doi: https://doi.org/10.3126/mujoei.v1i1.91094

    work page doi:10.3126/mujoei.v1i1.91094 2025

  27. [27]

    Multi-agent Reinforcement Learning: A Comprehensive Survey,

    D. Huh and P. Mohapatra, “Multi-agent Reinforcement Learning: A Comprehensive Survey,” arXiv.org, Dec. 15, 2023. https://arxiv.org/abs/2312.10256

    Pith/arXiv arXiv 2023

  28. [28]

    Exploiting Blockchain to Make AI Trustworthy: A Software Development Lifecycle View,

    P. Zhang, S. Ding, and Q. Zhao, “Exploiting Blockchain to Make AI Trustworthy: A Software Development Lifecycle View,” ACM Computing Surveys, Aug. 2023, doi: https://doi.org/10.1145/3614424

    work page doi:10.1145/3614424 2023

  29. [30]

    Automating code review activities by large-scale pre-training,

    Z. Li et al., “Automating code review activities by large-scale pre-training,” Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, Nov. 2022, doi: https://doi.org/10.1145/3540250.3549081

    arXiv 2022

  30. [31]

    A survey on large language models for software engineering,

    Q. Zhang et al., “A survey on large language models for software engineering,” Science China Information Sciences, vol. 69, no. 4, Mar. 2026, doi: https://doi.org/10.1007/s11432-025-4670-0

    doi:10.1007/s11432-025-4670-0 2026

  31. [32]

    Preliminary steps towards modeling blockchain oriented software,

    H. Rocha and S. Ducasse, “Preliminary steps towards modeling blockchain oriented software,” Proceedings of the 1st International Workshop on Emerging Trends in Software Engineering for Blockchain - WETSEB ’18, 2018, doi: https://doi.org/10.1145/3194113.3194123

    arXiv 2018

  32. [33]

    A Survey on Applications of Game Theory in Blockchain,

    Z. Liu et al., “A Survey on Applications of Game Theory in Blockchain,” arXiv:1902.10865 [cs], Mar. 2019, Available: https://arxiv.org/abs/1902.10865

    Pith/arXiv arXiv 1902

  33. [34]

    Multi-Agent Reinforcement Learning: A Selective Overview of Theories and Algorithms,

    K. Zhang, Z. Yang, and T. Başar, “Multi-Agent Reinforcement Learning: A Selective Overview of Theories and Algorithms,” Handbook of Reinforcement Learning and Control, pp. 321–384, 2021, doi: https://doi.org/10.1007/978- 3-030-60990-0_12

    doi:10.1007/978- 2021

  34. [951]

    Reporting both the mean and median therefore provides a more balanced description of the patch-length distribution

    The maximum value of 728,745 for (𝑦= 1) also shows that the training data contain extreme outliers. Reporting both the mean and median therefore provides a more balanced description of the patch-length distribution. Review-comment length is also examined as an observable indicator of available human feedback. Because the dataset distinguishes changes that...