Pith. sign in

REVIEW 4 major objections 6 minor 62 references

Automated Detection of Inter-Language Design Smells in Multi-Language Deep Learning Frameworks

T0 review · 4 major / 6 minor · reviewed 2026-08-11 · deepseek-v4-flash

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

Pith's one-line read This paper claims that seven inter-language design smells in Python/C++ deep learning frameworks can be detected automatically, and that the CPSMELL tool implementing the detection rules achieves 98.17% manually validated accuracy across…

desk verdict Useful catalog and tool for Python/C++ inter-language smells, but the 98.17% headline is precision against the tool's own rules, not evidence the smells are genuine defects. read the letter →

arxiv 2412.11869 v1 pith:Y6ZNKDG7 submitted 2024-12-16 cs.SE

Zengyang Li , Xiaoyong Zhang , Wenshuo Wang , Peng Liang , Ran Mo , Jie Tan , Hui Liu This is my paper · ORCID
classification cs.SE
keywords inter-languagedesignsmellsmulti-languagesoftwaredeeplearningframeworksPython/CAPIpybind11ctypessmelldetectionmaintainability
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 paper sets out to show that maintainability problems in multi-language deep learning frameworks can be captured as inter-language design smells: bad practices that arise only at the boundary where Python code meets C/C++ code. The authors define seven such smells, each with an explicit detection rule, and build a tool, CPSMELL, that implements the rules. They report a manually validated accuracy of 98.17% across five popular frameworks, and an empirical study of ten versions per framework showing that long lambda bindings and unused native code are the most common smells while the overall smell count rises over time. Success here would give maintainers a concrete checklist and an automated way to find code that hurts maintainability and that single-language smell detectors miss.

What carries the argument

The load-bearing mechanism is a catalog of seven ILDS, each paired with a deterministic detection rule written in terms of inter-language binding, calling, loading, and file-level call patterns. The CPSMELL pipeline turns C/C++ files into XML representations and Python files into abstract syntax trees, then a language-interface detector recognizes Python/C API, pybind11, and ctypes constructs, and a design-smell detector applies the rules with fixed thresholds, notably an 80-character limit for lambda functions in bindings and a limit of seven bound functions per class. The same machinery produces the empirical counts used in the distribution and evolution analysis.

What would settle it

Have independent experts who have never seen the detection rules label all inter-language design smells in a held-out set of Python/C++ deep learning framework files, then run CPSMELL on the same files and compare both precision and recall; if precision on this blind set falls well below 98.17% or recall turns out to be low, the accuracy claim and the empirical counts built on it would not survive.

Watch

Extended reading notes

Core claim

The central claim is that seven inter-language design smells—Unused Native Entity, Long Lambda Function For Inter-language Binding, Lack of Rigorous Error Check, Lack of Static Declaration, Not Using Relative Path, Large Inter-language Binding Class, and Excessive Inter-Language Communication—can be identified from the three communication mechanisms commonly used in Python/C++ frameworks (Python/C API, pybind11, and ctypes), and that a tool implementing the identification rules detects them with 98.17% accuracy in TensorFlow, PyTorch, Chainer, PaddlePaddle, and MindSpore. In the authors' empirical study, LLF and UNE together dominate the 982 detected instances, TensorFlow, PyTorch, and PaddlePaddle are the most smell-dense frameworks, and across three years of versions most frameworks show a fluctuating but generally increasing number of ILDS instances even though some smells, notably Excessive Inter-Language Communication and Large Inter-language Binding Class, are fixed at higher rates.

Load-bearing premise

The accuracy claim rests on treating the tool's own detection rules as the ground truth for what a true smell is, so the 98.17% figure mostly shows that the tool follows its own definitions; if that standard does not match what practitioners regard as harmful inter-language design, the accuracy number does not validate the smells.

Editorial extensions

If this is right

  • Maintainers of TensorFlow, PyTorch, and PaddlePaddle can use CPSMELL to locate the two most common smells, long lambda bindings and unused native entities, which together account for about three quarters of the 982 detected instances.
  • The near-zero fix rates for Lack of Rigorous Error Check and Not Using Relative Path imply that these smells persist across releases and need targeted cleanup rather than incidental improvement.
  • The overall upward trend in ILDS counts implies that adding inter-language APIs is currently introducing smells faster than refactoring removes them.
  • The high fix rates for Excessive Inter-Language Communication and Large Inter-language Binding Class suggest that architecture-level smells tend to disappear during major restructuring, not through small maintenance edits.
  • Because the tool recognizes only three communication mechanisms, the reported totals will undercount smells in code that uses other binding technologies such as SWIG or Cython.

Reading between the lines

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

  • The manual validation used the paper's own detection rules as the definition of a true instance, so the 98.17% figure is largely a measure of the tool's consistency with its rules; an independent expert panel working only from the informal smell descriptions could produce a materially different precision.
  • The paper reports precision but not recall, so the true number of ILDS instances in the five frameworks is unknown; the empirical distribution and upward-trend counts are likely lower bounds.
  • The thresholds, such as 80 characters, seven bound functions, and the number of native files called per Python file, are judgment calls that control which instances are counted; changing them would shift the observed rankings and fix ratios.
  • If the seven smells generalize, the same detection pipeline could be extended to other Python/C++ polyglot systems beyond deep learning, making inter-language maintainability measurable in a way that single-language tools cannot.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 6 minor

Summary. The paper proposes seven inter-language design smells (ILDS) for multi-language deep learning frameworks written in Python and C/C++, defines a detection rule for each smell, implements these rules in a tool called CPSMELL that parses three inter-language communication mechanisms (Python/C API, pybind11, ctypes), and manually validates the tool on five popular DLFs. The authors report an accuracy of 98.17% in this validation and then conduct an empirical study across ten versions of each DLF, analyzing the distribution of ILDS, the proportion of smells fixed between versions, and the evolution of smell counts. The abstract and the conclusion present the accuracy figure as the main evidence of the approach's effectiveness.

Significance. If the validation were methodologically sound, this would be a valuable contribution to maintainability analysis of multi-language systems: it provides a concrete catalog of seven inter-language smells with refactoring advice, an open implementation (CPSMELL) covering three ILCMs, and an empirical snapshot of smell prevalence and evolution in five widely used DLFs. The authors also publish their validation data and report inter-rater agreement (Kappa = 0.82), which supports the transparency of the manual labeling process. However, the central accuracy claim currently overstates what the validation establishes: the metric is precision, not accuracy, and the ground truth is largely defined by the tool's own detection rules, so the empirical study inherits this limitation.

major comments (4)
  1. [§4.2.2, §4.3, §4.4] The metric labeled 'accuracy' in the abstract and in Section 4.3 is defined in Section 4.2.2 as TP/(TP+FP), which is precision. No true negatives or false negatives are measured, and Section 4.4 explicitly states that recall is not computed. The headline figure '98.17% accuracy' should be renamed to 'precision' throughout, or supplemented with a recall estimate based on a gold standard that includes instances not detected by the tool. As written, the central claim is misleading.
  2. [§4.2.2] The validation ground truth is self-referential: criterion 1 in Section 4.2.2 states that a true ILDS instance 'should fully conform to the detection rule defined in Section 3,' and CPSMELL implements exactly those rules. Consequently, the TP/FP labels largely certify that the tool agrees with its own specification; the only independent human judgment is the special-case criterion, which produced all 18 false positives in Table 2. This protocol does not establish that the detected instances are genuine maintainability defects. I recommend an external validation step, such as confirmation of a sample of instances by the DLFs' maintainers or by independent developers who are given the smell descriptions but not the formal rules.
  3. [§3.7 (Rule 7), §5.3.1] The threshold MaxNBCallsFilesThreshold used by Rule 7 (EILC) is never disclosed. Section 5.3.1 even states that 'the exact threshold should be set according to practical needs.' Since EILC counts appear in Tables 2, 6, 7, and 9 and in the RQ1/RQ2 results, the EILC results are not reproducible. The paper should report the threshold value used in the experiments and, ideally, a sensitivity analysis over a range of thresholds.
  4. [Table 2, §6] The per-ILDS validation sets for LREC (9 instances), NURP (16), and EILC (19) are very small, so the 100% precision reported for these rows is not statistically robust. The paper acknowledges this imbalance in Section 6, but the overall 98.17% figure is dominated by LLF and UNE (741 of 982 instances). Please qualify the per-smell accuracy claims and avoid implying that all seven smells are equally well validated.
minor comments (6)
  1. [§3.3, Rule 3; §3.5, Rule 5] The formal rules contain garbled function identifiers (e.g., 'GetPyModule_AddObjectField', 'GetcdllField', 'GetCDLLField'). These should be replaced with the actual API names (PyModule_AddObject, CDLL, WinDLL, LoadLibrary) to make the rules readable and implementable.
  2. [§5.3.1] The sentence 'UNE instances in TensorFlow account for 67.71%' is inconsistent with Table 6, where the 67.71% belongs to LLF; the subsequent 30.90% for PyTorch also corresponds to LLF. Please correct the smell name.
  3. [§5.2.1 (Answer to RQ1)] The statement that LLF and UNE 'each ... accounting for over 25% of all the instances in each DLF' does not hold for PyTorch (UNE 15.94%) and MindSpore (UNE 21.74%, LLF 0%). Please rephrase to 'in most DLFs' or report the exact exceptions.
  4. [§3.2] Rule 2 uses an 80-character threshold for the lambda length, but the example in Listing 2 describes a lambda of 50 lines; please clarify whether the measure is characters, lines, or something else and ensure the threshold unit matches the implementation.
  5. [§4.3] The sentence 'the accuracy of detection for other six ILDS reaches 100%' should read 'other five ILDS' (LLF, LREC, LSD, LILBC, EILC), since UNE and NURP are the two exceptions.
  6. [§5.3.1] The exact percentages for lambda usage in PyTorch (78.71%) and TensorFlow (70.72%) are not shown in any table; please include the underlying data or remove the precise figures.

Circularity Check

1 steps flagged · score 4.0 of 10

The 98.17% validation accuracy is measured against a ground truth defined as 'fully conform to the detection rule' — exactly what CPSMELL implements — so the headline number largely certifies self-consistency; the only independent channel, contextual special-case review, produced all 18 reported false positives.

  1. self definitional [Section 4.2.2 (Data Analysis) and Section 4.3 (Validation Results)]
    "First, a true ILDS instance should fully conform to the detection rule defined in Section 3 for the corresponding ILDS. Second, combining the code context to determine if it falls into a special case, i.e., situations not covered by the rules. ... Accuracy = TP /(TP + FP )."

    The ground-truth label 'true ILDS instance' is defined as conformance to the Section 3 rules, and CPSMELL implements exactly those rules (Section 4.1). The validation therefore mostly checks whether the tool's output agrees with its own specification: flags matching the rule are counted as true, so the 98.17% figure reports internal consistency, not independent confirmation that the code is a genuine defect. The only independent oracle is criterion two, the contextual special-case review, and all 18 false positives in Table 2 arose there; the rule-conformance channel had zero false positives for the other smells. The metric is precision, TP/(TP+FP), not accuracy, and recall is unmeasured.

full rationale

The paper has one substantial self-referential step: the validation oracle is the detection rule itself. Section 4.2.2 states that a true ILDS instance 'should fully conform to the detection rule defined in Section 3', while Section 4.1 describes CPSMELL as implementing 'the detection rules for the 7 ILDS defined in Section 3'. Consequently the reported 98.17% is largely a measure of implementation-vs-spec consistency, not an independent check that each flagged instance harms maintainability. This is attenuated by the second validation criterion (special-case review in code context), which is genuinely independent and is where all 18 false positives were found, and by the external grounding of the smell catalog itself: the smells were mined from documentation, literature, GitHub issues, and Stack Overflow, and each had to appear in at least two DLFs and one authoritative source (Section 3). The paper also honestly discloses that no other detection tool exists for comparison and that recall was not measured (Section 4.4 and Limitations), which weakens the external validity of the headline number but is a completeness concern rather than circularity. Self-citations (e.g., the CPSMELL data link, Li et al. 2024b) are not load-bearing. Overall, the central claim is partially self-referential but retains independent content from the special-case review and the externally sourced smell definitions, so a moderate score of 4 is appropriate.

Assumptions & free parameters 5 free parameters · 4 assumptions · 7 invented entities

The central claims rest on several assumptions that the reader does not pay for upstream: that the three ILCMs cover the traffic, that the seven rules capture real maintainability defects, that static parsing finds all relevant calls, and that two manual validators can reliably judge ground truth. Thresholds for LLF, LILBC, and EILC are free parameters, two borrowed from literature and one unreported.

free parameters (5)
  • MaxLengthOfLFLThreshold = 80 characters
    Threshold in Rule 2 for Long Lambda Function, borrowed from Chen et al. (2016) and Google Python style guide; changes the LLF instance count.
  • MaxNBFunctionsThreshold = 7
    Threshold in Rule 6 for Large Inter-language Binding Class, taken from Abidi et al. (2021) and Lippert & Roock (2006).
  • MaxNBCallsFilesThreshold = not reported in the paper
    Threshold in Rule 7 for Excessive Inter-Language Communication; the paper never states its numeric value, and the Discussion says 'The number of EILC instances depends on the threshold definition'.
  • Minimum PL share for inclusion = 20% Python and C/C++
    Inclusion criterion for selecting DLFs in Section 4.2.1.
  • Minimum ILCM count for inclusion = 2 of 3 ILCMs
    Inclusion criterion in Section 4.2.1.
assumptions (4)
  • domain assumption The three ILCMs (Python/C API, pybind11, ctypes) cover the inter-language communication mechanisms that matter in the studied DLFs.
    Section 3 and Section 4.1; if other mechanisms (Cython, SWIG, CFFI, custom bindings) carry significant traffic, detection and RQ1/RQ3 conclusions miss them.
  • domain assumption The seven proposed ILDS are genuine maintainability defects.
    Section 3 claims negative impact; validation only checks rule conformance, not whether maintainers agree these smells harm maintainability.
  • domain assumption Static analysis through srcML and Python AST can identify all invocations and bindings for the three ILCMs.
    Section 4.1; dynamic dispatch via hasattr strings (Section 4.4) already shows this is incomplete.
  • domain assumption Manual labels, after Kappa >= 0.8, are reliable ground truth.
    Section 4.2.2; two authors label, and disagreements discussed, but only pilot sample is double-labeled.
invented entities (7)
  • Unused Native Entity (UNE)
    purpose: Identifies C/C++ entities bound in extension modules that are never imported or called from Python, so developers can remove dead inter-language code.
    Defined by Rule 1; precision estimated against the paper's own rules, with false positives from hasattr-mediated access (Section 4.4).
  • Long Lambda Function For Inter-language Binding (LLF)
    purpose: Flags lambda expressions used as native bindings that exceed 80 characters, hurting readability.
    Defined by Rule 2; threshold borrowed from Chen et al. (2016).
  • Lack of Rigorous Error Check (LREC)
    purpose: Flags PyModule_AddObject calls whose return value is not checked, risking memory leaks.
    Defined by Rule 3; only 9 instances found across the five DLFs.
  • Lack of Static Declaration (LSD)
    purpose: Flags bound C/C++ functions not declared static, risking symbol clashes across modules.
    Defined by Rule 4; grounded in Python C API documentation.
  • Not Using Relative Path (NURP)
    purpose: Flags ctypes DLL loads by bare name or absolute path instead of relative path, harming portability.
    Defined by Rule 5; false positives occur when path existence is checked (Section 4.4).
  • Large Inter-language Binding Class (LILBC)
    purpose: Flags C++ classes bound to Python with more than seven member functions.
    Defined by Rule 6; threshold from Abidi et al. (2021).
  • Excessive Inter-Language Communication (EILC)
    purpose: Flags Python files referencing more native files than a threshold, indicating high coupling.
    Defined by Rule 7; threshold value is not reported in the paper.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Automated Detection of Inter-Language Design Smells in Multi-Language Deep Learning Frameworks." pith.science (2026). https://pith.science/paper/Y6ZNKDG7

@misc{pith2026241211869,
  author       = {Pith},
  title        = {Pith review of: Automated Detection of Inter-Language Design Smells in Multi-Language Deep Learning Frameworks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/Y6ZNKDG7}},
  note         = {Machine review of arXiv:2412.11869}
}
read the original abstract

Nowadays, most DL frameworks (DLFs) use multilingual programming of Python and C/C++, facilitating the flexibility and performance of the DLF. However, inappropriate interlanguage interaction may introduce design smells involving multiple programming languages (PLs), i.e., Inter-Language Design Smells (ILDS). Despite the negative impact of ILDS on multi-language DLFs, there is a lack of an automated approach for detecting ILDS in multi-language DLFs and a comprehensive understanding on ILDS in such DLFs. This work automatically detects ILDS in multi-language DLFs written in the combination of Python and C/C++, and to obtain a understanding on such ILDS in DLFs. We first developed an approach to automatically detecting ILDS in the multi-language DLFs written in the combination of Python and C/C++, including a number of ILDS and their detection rules defined based on inter-language communication mechanisms and code analysis. We then developed the CPSMELL tool that implements detection rules for automatically detecting such ILDS, and manually validated the accuracy of the tool. Finally, we performed a study to evaluate the ILDS in multi-language DLFs. We proposed seven ILDS and achieved an accuracy of 98.17% in the manual validation of CPSMELL in 5 popular multi-language DLFs. The study results revealed that among the 5 DLFs, TensorFlow, PyTorch, and PaddlePaddle exhibit relatively high prevalence of ILDS; each smelly file contains around 5 ILDS instances on average, with ILDS Long Lambda Function For Inter-language Binding and Unused Native Entity being relatively prominent; throughout the evolution process of the 5 DLFs, some ILDS were resolved to a certain extent, but the overall count of ILDS instances shows an upward trend. The automated detection of the proposed ILDS achieved a high accuracy, and the study provides a comprehensive understanding on ILDS in the multi-language DLFs.

Figures

Figures reproduced from arXiv: 2412.11869 by the authors.

Figure 1
Figure 1. Inter-language design smell extraction process et al., 2023). However, the ILCMs used by different multi-language software systems vary significantly, and a single software system may employ multiple ILCMs. By reading the source code of multiple popular DLFs, our study identified three ILCMs that are commonly used in DLFs, namely Python/C API (Foundation, 2019b), pybind11 (Jakob, 2017) and ctypes (Foundation, 2019a)… view at source ↗
Figure 2
Figure 2. Process of creating an extension module using the Python/C API development work. Therefore, it is necessary to implement rigorous error detection for this function. Refactoring Recommendation: According to the of￾ficial Python documentation (Python, 2023b), it is recom￾mended to use the new PYMODULE_ADDOBJECTREF() in Python 3.10 instead of PYMODULE_ADDOBJECT(). The PYMODULE_ADDOBJECTREF() function will not steal the… view at source ↗
Figure 3
Figure 3. An example of design smell Excessive Inter-Language Communication 4. Implementation and Validation 4.1. Implementation of ILDS Detection To implement the detection rules for the 7 ILDS defined in Section 3, we developed the CPSMELL toolkit (Li et al., 2024b). The entire execution process of CPSMELL is shown in [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Execution process of the CPsmell tool Python and C/C++. In addition, CPSMELL explicitly records information about each identified ILDS instance, facilitating developers in locating the specific files and code lines asso￾ciated with each smell. 4.2. Validation Design To…
Figure 5
Figure 5. Figure 5: The evolution of ILDS in the 5 DLFs (RQ3) As shown in [PITH_FULL_IMAGE:figures/full_fig_p013_5.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

62 extracted references · 59 canonical work pages

  1. [1]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in ":" * " " * FUNCTION f...

  2. [2]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in ":" * " " * FUNCTION f...

  3. [3]

    , author Barham, P

    author Abadi, M. , author Barham, P. , author Chen, J. , author Chen, Z. , author Davis, A. , author Dean, J. , author Devin, M. , author Ghemawat, S. , author Irving, G. , author Isard, M. , et al., year 2016 . title TensorFlow : a system for large-scale machine learning , in: booktitle Proceedings of the 12th USENIX symposium on operating systems design...

    work page 2016

  4. [4]

    , author Grichi, M

    author Abidi, M. , author Grichi, M. , author Khomh, F. , author Gu \'e h \'e neuc, Y.G. , year 2019 a. title Code smells for multi-language systems , in: booktitle Proceedings of the 24th European conference on pattern languages of programs (EuroPLoP) , publisher ACM , address Irsee, Germany . pp. pages 1--13

    work page 2019

  5. [5]

    , author Khomh, F

    author Abidi, M. , author Khomh, F. , author Gu \'e h \'e neuc, Y.G. , year 2019 b. title Anti-patterns for multi-language systems , in: booktitle Proceedings of the 24th European conference on pattern languages of programs (EuroPLoP) , publisher ACM , address Irsee, Germany . pp. pages 1--14

    work page 2019

  6. [6]

    , author Rahman, M.S

    author Abidi, M. , author Rahman, M.S. , author Openja, M. , author Khomh, F. , year 2021 . title Are multi-language design smells fault-prone? an empirical study . journal ACM Transactions on Software Engineering and Methodology volume 30 , pages 1--56

    work page 2021

  7. [7]

    title Paddlepaddle

    author Baidu , year 2023 a. title Paddlepaddle . note https://github.com/PaddlePaddle/Paddle/blob/v2.4.2/python/paddle/fluid/dygraph/varbase\_patch\_methods.py https://github.com/PaddlePaddle/Paddle/blob/v2.4.2/python/paddle/fluid/dygraph/varbase_patch_methods.py

    work page 2023

  8. [8]

    title Paddlepaddle releases

    author Baidu , year 2023 b. title Paddlepaddle releases . note https://github.com/PaddlePaddle/Paddle/releases https://github.com/PaddlePaddle/Paddle/releases

    work page 2023

Show all 62 references
  1. [9]

    , author Chen, L

    author Chen, Z. , author Chen, L. , author Ma, W. , author Xu, B. , year 2016 . title Detecting code smells in python programs , in: booktitle Proceedings of the 2016 international conference on Software Analysis, Testing and Evolution (SATE) , publisher IEEE , address Kunming...

    2016

  2. [10]

    title Pytorch

    author Facebook , year 2018 . title Pytorch . note https://github.com/pytorch/pytorch/blob/v0.3.1/torch/csrc/Size.cpp https://github.com/pytorch/pytorch/blob/v0.3.1/torch/csrc/Size.cpp

    2018

  3. [11]

    title Pytorch

    author Facebook , year 2019 . title Pytorch . note https://github.com/pytorch/pytorch/blob/v1.1.0/torch/csrc/Size.cpp https://github.com/pytorch/pytorch/blob/v1.1.0/torch/csrc/Size.cpp

    2019

  4. [12]

    title Pytorch

    author Facebook , year 2022 . title Pytorch . note https://github.com/pytorch/pytorch/blob/v1.11.0/torch/csrc/deploy/test\_deploy\_lib.cpp https://github.com/pytorch/pytorch/blob/v1.11.0/torch/csrc/deploy/test\_deploy\_lib.cpp

    2022

  5. [13]

    title Pytorch

    author Facebook , year 2023 a. title Pytorch . note https://github.com/pytorch/pytorch/blob/v2.0.0/torch/csrc/Module.cpp https://github.com/pytorch/pytorch/blob/v2.0.0/torch/csrc/Module.cpp

    2023

  6. [14]

    title Pytorch

    author Facebook , year 2023 b. title Pytorch . note https://github.com/pytorch/pytorch/blob/v2.0.1/torch/cuda/\_\_init\_\_.py https://github.com/pytorch/pytorch/blob/v2.0.1/torch/cuda/__init__.py

    2023

  7. [15]

    title Pytorch

    author Facebook , year 2023 c. title Pytorch . note https://github.com/pytorch/pytorch/blob/v2.0.1/torch/\_inductor/codecache.py https://github.com/pytorch/pytorch/blob/v2.0.1/torch/_inductor/codecache.py

    2023

  8. [16]

    title Pytorch

    author Facebook , year 2023 d. title Pytorch . note https://github.com/pytorch/pytorch/blob/v2.0.1/torch/utils/benchmark/utils/valgrind\_wrapper/timer\_interface.py https://github.com/pytorch/pytorch/blob/v2.0.1/torch/utils/benchmark/utils/valgrind_wrapper/timer_interface.py

    2023

  9. [17]

    , year 2019 a

    author Foundation, P.S. , year 2019 a. title ctypes — a foreign function library for python . note https://docs.python.org/3/library/ctypes.html https://docs.python.org/3/library/ctypes.html

    2019

  10. [18]

    , year 2019 b

    author Foundation, P.S. , year 2019 b. title Extending and embedding the python interpreter . note https://docs.python.org/zh-cn/3.8/extending/index.html\#extending-index https://docs.python.org/zh-cn/3.8/extending/index.html\#extending-index

    2019

  11. [19]

    , year 2018

    author Fowler, M. , year 2018 . title Refactoring . edition 2nd ed., publisher Addison-Wesley Professional

    2018

  12. [20]

    , author Liu, S

    author Gesi, J. , author Liu, S. , author Li, J. , author Ahmed, I. , author Nagappan, N. , author Lo, D. , author de Almeida, E.S. , author Kochhar, P.S. , author Bao, L. , year 2022 . title Code smells in machine learning systems . journal arXiv preprint arXiv:2203.00803

    2022 arXiv

  13. [21]

    title Google python style guide

    author Google , year 2023 a. title Google python style guide . note https://google.github.io/styleguide/pyguide.html https://google.github.io/styleguide/pyguide.html

    2023

  14. [22]

    title Tensorflow

    author Google , year 2023 b. title Tensorflow . note https://github.com/tensorflow/tensorflow/blob/v2.12.0/tensorflow/python/tfe\_wrapper.cc https://github.com/tensorflow/tensorflow/blob/v2.12.0/tensorflow/python/tfe\_wrapper.cc

    2023

  15. [23]

    title Tensorflow

    author Google , year 2023 c. title Tensorflow . note https://github.com/tensorflow/tensorflow/blob/v2.12.0/tensorflow/compiler/xla/python/xla.cc https://github.com/tensorflow/tensorflow/blob/v2.12.0/tensorflow/compiler/xla/python/xla.cc

    2023

  16. [24]

    , year 2020

    author Grichi, M. , year 2020 . title Towards Understanding Modern Multi-Language Software\\ Systems . Ph.D. thesis. Ecole Polytechnique, Montreal, Canada

    2020

  17. [25]

    , author Abidi, M

    author Grichi, M. , author Abidi, M. , author Jaafar, F. , author Eghan, E.E. , author Adams, B. , year 2021 . title On the impact of interlanguage dependencies in multilanguage systems empirical case study on java native interface applications (jni) . journal IEEE Transaction...

    2021

  18. [26]

    , author Eghan, E.E

    author Grichi, M. , author Eghan, E.E. , author Adams, B. , year 2020 . title On the impact of multi-language development in machine learning frameworks , in: booktitle Proceedings of the 36th IEEE International Conference on Software Maintenance and Evolution (ICSME) , organi...

    2020

  19. [27]

    , author Venegas, L.O

    author Groot, T. , author Venegas, L.O. , author Laz a r, B. , author Kr \"u ger, J. , year 2024 . title A catalog of unintended software dependencies in multi-lingual systems at asml , in: booktitle Proceedings of the 46th International Conference on Software Engineering: Sof...

    2024

  20. [28]

    , author Maletic, J.I

    author Hayworth, M. , author Maletic, J.I. , year 2022 . title pylibsrcml . note https://github.com/srcML/pylibsrcml https://github.com/srcML/pylibsrcml

    2022

  21. [29]

    , author Zhang, Y

    author Hu, M. , author Zhang, Y. , year 2020 . title The python/c api: evolution, usage statistics, and bug patterns , in: booktitle Proceedings of the 27th International Conference on Software Analysis, Evolution and Reengineering (SANER) , organization IEEE . pp. pages 532--536

    2020

  22. [30]

    title Mindspore

    author Huawei , year 2023 . title Mindspore . note https://github.com/mindspore-ai/mindspore/blob/v2.0.0/mindspore/ccsrc/pybind\_api/ir/tensor\_py.cc https://github.com/mindspore-ai/mindspore/blob/v2.0.0/mindspore/ccsrc/pybind_api/ir/tensor_py.cc

    2023

  23. [31]

    , year 2022

    author Huawei Technologies Co., L. , year 2022 . title Huawei mindspore ai development framework , in: booktitle Artificial Intelligence Technology . publisher Springer , pp. pages 137--162

    2022

  24. [32]

    , year 2017

    author Jakob, W. , year 2017 . title pybind11 — seamless operability between c++11 and python . note https://pybind11.readthedocs.io/en/stable/index.html https://pybind11.readthedocs.io/en/stable/index.html

    2017

  25. [33]

    , author Ben Braiek, H

    author Jebnoun, H. , author Ben Braiek, H. , author Rahman, M.M. , author Khomh, F. , year 2020 . title The scent of deep learning code: An empirical study , in: booktitle Proceedings of the 17th International Conference on Mining Software Repositories (MSR) , pp. pages 420--430

    2020

  26. [34]

    , author Wijedasa, D

    author Kochhar, P.S. , author Wijedasa, D. , author Lo, D. , year 2016 . title A large scale study of multiple programming languages and code quality , in: booktitle Proceedings of the 23rd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER...

    2016

  27. [35]

    , author Winter, A

    author Kullbach, B. , author Winter, A. , author Dahm, P. , author Ebert, J. , year 1998 . title Program comprehension in multi-language systems , in: booktitle Proceedings of the 5th Working Conference on Reverse Engineering (WCRE) , organization IEEE . pp. pages 135--143

    1998

  28. [36]

    , author Li, L

    author Li, W. , author Li, L. , author Cai, H. , year 2022 a. title On the vulnerability proneness of multilingual code , in: booktitle Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE...

    2022

  29. [37]

    , author Li, L

    author Li, W. , author Li, L. , author Cai, H. , year 2022 b. title Polyfax: a toolkit for characterizing multi-language software , in: booktitle Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering...

    2022

  30. [38]

    , author Marino, A

    author Li, W. , author Marino, A. , author Yang, H. , author Meng, N. , author Li, L. , author Cai, H. , year 2024 a. title How are multilingual systems constructed: Characterizing language use and selection in open-source multilingual software . journal ACM Transactions on So...

    2024

  31. [39]

    , author Ming, J

    author Li, W. , author Ming, J. , author Luo, X. , author Cai, H. , year 2022 c. title PolyCruise : A cross-language dynamic information flow analysis , in: booktitle Proceedings of the 31st USENIX Security Symposium (USENIX Security) , pp. pages 2513--2530

    2022

  32. [40]

    , author Avgeriou, P

    author Li, Z. , author Avgeriou, P. , author Liang, P. , year 2015 . title A systematic mapping study on technical debt and its management . journal Journal of Systems and Software volume 101 , pages 193--220

    2015

  33. [41]

    , author Wang, S

    author Li, Z. , author Wang, S. , author Wang, W. , author Liang, P. , author Mo, R. , author Li, B. , year 2023 a. title Understanding bugs in multi-language deep learning frameworks , in: booktitle Proceedings of the 31st International Conference on Program Comprehension (IC...

    2023

  34. [42]

    , author Wang, W

    author Li, Z. , author Wang, W. , author Wang, S. , author Liang, P. , author Mo, R. , year 2023 b. title Understanding resolution of multi-language bugs: An empirical study on apache projects , in: booktitle Proceedings of the 17th ACM/IEEE International Symposium on Empirica...

    2023

  35. [43]

    , author Zhang, X

    author Li, Z. , author Zhang, X. , author Wang, W. , author Liang, P. , author Mo, R. , author Tan, J. , author Liu, H. , year 2024 b. title Cpsmell . note https://github.com/ILDSOFDLF/cpsmell https://github.com/ILDSOFDLF/cpsmell

    2024

  36. [44]

    , author Roock, S

    author Lippert, M. , author Roock, S. , year 2006 . title Refactoring in large software projects: performing complex restructurings successfully . publisher John Wiley & Sons

    2006

  37. [45]

    , author Yu, D

    author Ma, Y. , author Yu, D. , author Wu, T. , author Wang, H. , year 2019 . title Paddlepaddle: An open-source deep learning platform from industrial practice . journal Frontiers of Data and Domputing volume 1 , pages 105--115

    2019

  38. [46]

    , author Kirsch, M

    author Mayer, P. , author Kirsch, M. , author Le, M.A. , year 2017 . title On multi-language software development, cross-language links and accompanying tools: a survey of professional software developers . journal Journal of Software Engineering Research and Development volum...

    2017

  39. [47]

    , author Gu \'e h \'e neuc, Y.G

    author Moha, N. , author Gu \'e h \'e neuc, Y.G. , author Duchien, L. , author Le Meur, A.F. , year 2009 . title Decor: A method for the specification and detection of code and design smells . journal IEEE Transactions on Software Engineering volume 36 , pages 20--36

    2009

  40. [48]

    , author Ouadjaout, A

    author Monat, R. , author Ouadjaout, A. , author Min \'e , A. , year 2021 . title A multilanguage static analysis of python programs with native c extensions , in: booktitle Proceedings of the 28th International Static Analysis Symposium (SAS) , organization Springer . pp. pag...

    2021

  41. [49]

    , year 2017

    author Overflow, S. , year 2017 . title What is the path of the loaded dll? note https://stackoverflow.com/questions/44453489/what-is-the-path-of-the-loaded-dll https://stackoverflow.com/questions/44453489/what-is-the-path-of-the-loaded-dll

    2017

  42. [50]

    , author Gross, S

    author Paszke, A. , author Gross, S. , author Massa, F. , author Lerer, A. , author Bradbury, J. , author Chanan, G. , author Killeen, T. , author Lin, Z. , author Gimelshein, N. , author Antiga, L. , et al., year 2019 . title Pytorch: An imperative style, high-performance dee...

    2019

  43. [51]

    title Abstract syntax tree

    author Python , year 2019 . title Abstract syntax tree . note https://docs.python.org/3/library/ast.html\# https://docs.python.org/3/library/ast.html\#

    2019

  44. [52]

    title Extending python with c or c++

    author Python , year 2023 a. title Extending python with c or c++ . note https://docs.python.org/zh-cn/3/extending/extending.html https://docs.python.org/zh-cn/3/extending/extending.html

    2023

  45. [53]

    title Python/c api

    author Python , year 2023 b. title Python/c api . note https://docs.python.org/3/c-api/module.html\#c.PyModule\_AddObject https://docs.python.org/3/c-api/module.html\#c.PyModule\_AddObject

    2023

  46. [54]

    , year 2018

    author Rossum, G.v. , year 2018 . title Extending and embedding python: Release 3.6. 4

    2018

  47. [55]

    , author Oono, K

    author Tokui, S. , author Oono, K. , author Hido, S. , author Clayton, J. , year 2015 . title Chainer: a next-generation open source framework for deep learning , in: booktitle Proceedings of workshop on machine learning systems (LearningSys) in the twenty-ninth annual confere...

    2015

  48. [56]

    , author Cruz, L

    author Van Oort, B. , author Cruz, L. , author Aniche, M. , author Van Deursen, A. , year 2021 . title The prevalence of code smells in machine learning projects , in: booktitle Proceedings of the IEEE/ACM 1st Workshop on AI Engineering-Software Engineering for AI (WAIN) , org...

    2021

  49. [57]

    , author Garrett, J.M

    author Viera, A.J. , author Garrett, J.M. , et al., year 2005 . title Understanding interobserver agreement: the kappa statistic . journal Family Medicine volume 37 , pages 360--363

    2005

  50. [58]

    , author Lian, W

    author Yang, H. , author Lian, W. , author Wang, S. , author Cai, H. , year 2023 . title Demystifying issues, challenges, and solutions for multilingual software development , in: booktitle Proceedings of the IEEE/ACM 45th International Conference on Software Engineering (ICSE...

    2023

  51. [59]

    , author Nong, Y

    author Yang, H. , author Nong, Y. , author Wang, S. , author Cai, H. , year 2024 . title Multi-language software development: Issues, challenges, and solutions . journal IEEE Transactions on Software Engineering

    2024

  52. [60]

    , author He, T

    author Yang, Y. , author He, T. , author Xia, Z. , author Feng, Y. , year 2022 . title A comprehensive empirical study on bug characteristics of deep learning frameworks . journal Information and Software Technology volume 151 , pages 107004

    2022

  53. [61]

    , author Lee, S

    author Youn, D. , author Lee, S. , author Ryu, S. , year 2023 . title Declarative static analysis for multilingual programs using codeql . journal Software: Practice and Experience

    2023

  54. [62]

    , author Cruz, L

    author Zhang, H. , author Cruz, L. , author Van Deursen, A. , year 2022 . title Code smells for machine learning applications , in: booktitle Proceedings of the 1st International Conference on AI Engineering: Software Engineering for AI , pp. pages 217--228

    2022

Pith tools

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