Pith. sign in

REVIEW 4 major objections 5 minor 1 cited by

Extracting Overlapping Microservices from Monolithic Code via Deep Semantic Embeddings and Graph Neural Network-Based Soft Clustering

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

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

Pith's one-line read Monolithic code splits into better microservices when classes may belong to several services at once, not just one.

desk verdict Genuinely novel soft-clustering idea, but the headline gains are an artifact of computing metrics on overlapping partitions against hard baselines. read the letter →

arxiv 2508.07486 v1 pith:F4BMXRHG submitted 2025-08-10 cs.SE cs.AIcs.CV

Morteza Ziabakhsh , Kiyan Rezaee , Sadegh Eskandari , Seyed Amir Hossein Tabatabaei , Mohammad M. Ghassemi This is my paper · ORCID
classification cs.SEcs.AIcs.CV
keywords microserviceextractionsoftclusteringoverlappingservicesgraphneuralnetworkssemanticembeddingsmonolithdecompositionUniXcoderNOCD
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

The paper claims that microservice extraction from monolithic code should be treated as soft clustering: classes may belong probabilistically to multiple microservices, rather than being forced into exactly one. It introduces Mo2oM, which combines semantic embeddings of source code from a code-focused transformer with structural dependencies from method-call graphs, then uses a graph neural network-based overlapping community detector to produce a class-to-service membership matrix. On four open-source monoliths, it reports that this approach beats eight hard-clustering baselines, with gains up to 40.97% in structural modularity, a 58% reduction in inter-service call percentage, 26.16% fewer interfaces, and 38.96% better service-size balance. A sympathetic reader would care because the method turns a practical observation—real expert decompositions sometimes share cross-cutting classes across services—into a measurable architectural claim.

What carries the argument

The central mechanism is the soft class-to-service membership matrix produced by NOCD (Neural Overlapping Community Detection), a two-layer graph convolutional network trained by maximizing the likelihood of observed edges under a Bernoulli-Poisson model. It takes the binarized structural-dependency graph as adjacency and either structural or semantic vectors as node features. Averaging the two membership matrices with weight $\alpha$ and thresholding by $\tau$ turns continuous probabilistic memberships into the final overlapping microservice decomposition.

What would settle it

Take each Mo2oM output and force every class into only its highest-membership service, then recompute the four metrics; if the reported gains over hard-clustering baselines largely vanish or reverse, the improvements depend on the overlap counting convention rather than on genuinely better service boundaries.

Watch

Extended reading notes

Core claim

Mo2oM's central claim is that allowing overlapping class memberships directly improves microservice decomposition quality. Each class is represented twice: once by semantic content (tokens, comments, and a flattened abstract syntax tree) embedded with UniXcoder, and once by normalized method-call influences between classes. Two instances of the NOCD graph neural network learn soft membership rows from these features, producing $M^{\text{sem}}$ and $M^{\text{str}}$, which are fused as $M = \alpha M^{\text{sem}} + (1-\alpha) M^{\text{str}}$. A class is assigned to microservice $j$ when $M_{ij} \geq \tau$. With $\alpha > 0.5$ and $\tau \in [0.1, 0.3]$, the paper argues that semantic weighting p

Load-bearing premise

The evaluation assumes that computing the four metrics on a thresholded soft assignment, where a class can count as inside several services at once, is a fair comparison against hard partitions, even though overlap by construction moves cross-service calls inside services.

Editorial extensions

If this is right

  • If Mo2oM is correct, decomposition tools should stop enforcing one-service-per-class: sharing cross-cutting classes is a feature, not a failure.
  • Semantic embeddings carry more decomposition signal than structural call counts alone, since the best configurations weigh the semantic matrix more heavily ($\alpha > 0.5$).
  • The threshold $\tau$ acts as a tunable overlap strictness knob, letting engineers trade tighter modularity against lower inter-service communication.
  • The same soft-clustering pipeline applies to refactoring already-decomposed microservice systems, not only to migrating monoliths.
  • Because the number of microservices can be fixed in advance, Mo2oM could fit deployment budgets that range from a few large services to many small ones.

Reading between the lines

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

  • The reported 58% inter-service-call reduction is partly definitional: under soft assignment, a call between two classes that both belong to service $S$ is counted as intra-service even if those classes also serve elsewhere, so a hard re-partitioning of the same output would likely erase much of the gain.
  • The four evaluation monoliths are small (37–108 classes); on larger industrial codebases the benefit of overlap may shrink once duplicated code and deployment coordination costs are included.
  • A direct comparison against fuzzy or overlapping variants of existing baselines (rather than only hard-clustering baselines) would isolate how much of the improvement comes from soft assignment alone versus from UniXcoder embeddings.
  • The paper acknowledges maintenance overhead from repeated class definitions but leaves open how overlaps are physically deployed—duplicated code, shared libraries, or shared services—so a cost model is still needed before adoption.
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 / 5 minor

Summary. The paper proposes Mo2oM, a microservice-extraction framework that formulates decomposition as a soft clustering problem. Each class is assigned probabilistically to multiple microservices via a graph neural network (NOCD) that fuses UniXcoder semantic embeddings with method-call-graph structure; a threshold on the membership matrix produces overlapping services. The evaluation compares Mo2oM against eight hard-clustering baselines on four Java monoliths using structural modularity (SM), inter-service call percentage (ICP), interface number (IFN), and non-extreme distribution (NED), reporting large gains (e.g., up to 40.97% SM, 58% ICP reduction). The paper also includes ablations replacing soft clustering with hard assignment and UniXcoder with TF-IDF, plus hyperparameter sensitivity analysis.

Significance. If the empirical claims were sound, the paper would make a meaningful contribution: it introduces a realistic overlap motivation (cross-cutting classes like MetricConfig in Spring Petclinic), a concrete soft-clustering formulation, and a reproducible pipeline with public code and datasets. The ablation design, comparing identical features under soft versus hard assignment, is a useful diagnostic. However, the central evaluation is currently confounded by a metric-compatibility problem: SM, ICP, and NED are computed on overlapping outputs while all baselines are hard partitions, so part of the reported improvement is built into the output representation rather than into the quality of the learned embeddings or clustering. This must be corrected before the headline results can be interpreted.

major comments (4)
  1. [Soft Clustering / Eq. (8) and Table 1] The headline comparison is not commensurable. In Eq. (8), class Ci is assigned to every service with Mij >= τ; Table 1 then reports SM, ICP, and NED on this overlapping output. A call between two classes counts as intra-service if the classes share any service, so duplicating a class into multiple services mechanically lowers ICP and raises SM, independent of semantic quality. Table 2 demonstrates this: UniXcoder + Hard gives JPetStore ICP=0.407 and SM=0.097, while UniXcoder + Soft gives ICP=0.120 and SM=0.289 with identical features. No baseline is allowed to overlap and no trivial-overlap control (e.g., random duplication with the same overlap budget) is provided. The abstract's '58% ICP reduction' and 'up to 40.97% SM' therefore cannot be attributed to the GNN or embeddings; they may be artifacts of the extra degrees of freedom in the output.
  2. [Implementation Details / Figure 4] Hyperparameters α, τ, and the cluster count N are tuned on the same four benchmarks used for the final comparison, using QSCORE (Eq. 10). Because the tuning set is the test set, the reported improvements may reflect overfitting rather than general superiority. The paper should either adopt a held-out validation protocol, or report performance across the full α/τ range and show that the ranking against baselines is stable, at least for the most favorable region of the parameter space.
  3. [Ablation Study / Table 3] The TF-IDF + Soft variant outperforms UniXcoder + Soft on ICP in two of four benchmarks and on SM in two benchmarks; the text emphasizes average gains and de-emphasizes these reversals. More importantly, since both variants use soft assignments, the comparison cannot separate the contribution of semantic embeddings from the soft-clustering artifact described above. Adding TF-IDF + Hard and UniXcoder + Hard would allow a cleaner attribution of improvements to each component.
  4. [Evaluation Metrics / Eq. (9)] The NED metric is 'slightly modified' for soft clustering by counting the size of each service after thresholding, so duplicated classes inflate service sizes in a way that is not comparable to hard partitions. This compounds the incomparability of metric values in Table 1. The paper should either evaluate all methods on a common hard projection (e.g., argmax or a deterministic tie-breaking) or use overlapping-community metrics that are defined for soft outputs.
minor comments (5)
  1. [Eq. (10)] There is a typo in the QSCORE formula: '− ]NED' should be '− ĝ_NED' (hat is missing).
  2. [Related Work] The baseline is referred to as both 'GCD-DVF' and 'GDC-DVF'; the latter appears to be the intended acronym (see also Table 1 and the references).
  3. [Table 2 and Table 1] The 'UniXcoder + Soft' values in Table 2 (e.g., JPetStore SM=0.289, ICP=0.120) differ slightly from the 'Mo2oM (ours)' values in Table 1 (SM=0.288, ICP=0.153). The relationship between these two configurations should be clarified (different hyperparameters? different runs?).
  4. [Discussion / Figure 5] The application to thirteen real-world microservices applications is presented without describing how the original 'decomposition' is obtained or whether the metrics are computed on the same class/service granularity as the monolith experiments. This makes the refactoring claim hard to verify.
  5. [References] References [38] and [39] appear to describe the same work (arXiv preprint and Expert Systems article); please unify or cross-reference as appropriate.

Circularity Check

2 steps flagged · score 6.0 of 10

Reported ICP/SM gains over hard baselines are largely artifacts of thresholded overlap, not of the learned embeddings; per-benchmark tuning on QSCORE further in-samples the results.

  1. other [Soft Clustering (Eq. 8 + threshold); Evaluation Metrics; Table 2]
    "Class Ci is assigned to jth microservice when Mij ≥ τ, with threshold τ ∈ (0, 1) controlling assignment strictness. Classes with all Mij < τ are flagged as outliers. ... A common constraint across all baselines is the assignment of each class to at most one microservice. ... ICP quantifies the proportion of method calls occurring across services, with lower values reflecting better cohesion and less communication overhead between microservices. ... In this study, we use a slightly modified version of NED so that it works in soft clustering scenarios as well."

    Because SM and ICP are computed on the thresholded output of Eq. (8), every class assigned to more than one service can make calls to classes in each of its services count as intra-service. The improvement in ICP/SM over hard baselines is therefore guaranteed by the output representation, not by the semantic embeddings or GNN. Table 2 isolates this: with identical UniXcoder features, switching from hard argmax to soft thresholding changes JPetStore ICP from 0.407 to 0.120 and SM from 0.097 to 0.289; Table 3 shows TF-IDF+Soft nearly matches UniXcoder+Soft on JPetStore ICP (0.121 vs 0.120), so the advertised 58% ICP reduction is an overlap artifact. No baseline is allowed to overlap and no random-overlap control is reported.

  2. fitted input called prediction [Experiments, Hyperparameter Sensitivity Analysis (Eq. 10, Fig. 4)]
    "For this analysis, we introduce a composite quality score, QSCORE, which aggregates normalized evaluation metrics as follows: QSCORE = gSM − gICP − gIFN − ]NED. ... A consistent pattern emerges: a bright yellow region at the bottom-right of each heatmap suggests optimal results with higher α (semantic-heavy weighting) and lower τ (more permissive threshold)."

    α and τ are selected per benchmark by maximizing QSCORE, a composite of the same four metrics (SM, ICP, IFN, NED) later reported as results. Since the paper describes no separate validation split or held-out benchmark for this selection, the numbers in Table 1 are in-sample optima of the evaluation function, not independent predictions. The claimed 'improvements' are therefore partly forced by the tuning procedure rather than by the model's generalization.

full rationale

This paper does not rely on self-citation loops: NOCD [31], UniXcoder [5], and the benchmarks are external, and the method is implemented against public repositories. The central issue is in the evaluation, not the derivation. Eq. (8) defines the final assignment by thresholding a membership matrix; a class can be placed in every service whose membership is above τ. SM and ICP are then computed on that overlapped assignment, while all eight baselines are restricted to hard partitions. Calls from a duplicated class to classes in any of its services become intra-service calls, so ICP falls and SM rises as overlap increases—mechanically, without changing the underlying dependency structure. Table 2 confirms the mechanism: with the same UniXcoder features, hard argmax yields JPetStore ICP 0.407 and SM 0.097, while thresholded overlap yields ICP 0.120 and SM 0.289. Table 3 shows TF-IDF+Soft is competitive with UniXcoder+Soft on JPetStore (ICP 0.121 vs 0.120), indicating the headline advantage over hard baselines is delivered by the overlap representation, not by deep semantic embeddings. The paper explicitly modifies NED for soft scenarios but does not modify or re-justify SM/ICP, and it reports no random-overlap control. The limitation section acknowledges that overlap adds maintenance overhead, which reinforces that the ICP reduction does not correspond to actual communication savings. A second, smaller circularity risk is hyperparameter selection: α and τ are explored per benchmark and judged with QSCORE, a composite of the four reported metrics; with no held-out split described, the final numbers are in-sample optima of the evaluation function. These two issues make the central SOTA claim largely an artifact of the output representation and tuning, so the circularity score is 6 rather than 0-2. The method's core idea (soft clustering) is legitimate and the semantic-vs-TF-IDF comparison is independent, which prevents a higher score.

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

The method itself is a composition of existing components; the only numbers fitted to the test data are alpha, tau, and N. Evaluation rests on unstated assumptions about metric comparability and generalization.

free parameters (3)
  • alpha = reported optimal range 0.6 to 1.0
    Weight balancing semantic and structural membership matrices (Eq. 8); tuned by grid search on each benchmark using QSCORE, exact final values not disclosed.
  • tau = reported optimal range 0.1 to 0.3
    Threshold controlling soft assignment strictness; tuned per benchmark, exact final values not disclosed.
  • N = scanned from ceil(Y/2) down to minimum 2 or 3
    Target microservice count; the selection rule for the final N is not specified, so it may be chosen to maximize evaluation metrics.
assumptions (4)
  • domain assumption Classes are the smallest decomposition unit and method-call graphs capture architectural dependencies.
    The pipeline parses each class and builds structural features from method invocations; the entire approach assumes class-level granularity is correct for microservice boundaries.
  • domain assumption The adjacency matrix A = 1[Sstr > 0] is the appropriate input graph for NOCD; semantic similarity enters only as node features, not as graph structure.
    Eq. 4 defines A from structural calls only, so semantic relationships cannot create edges between classes with no structural interaction.
  • domain assumption SM, ICP, IFN, and NED computed on overlapping assignments measure maintainable microservice quality.
    The evaluation compares soft outputs to hard baselines with metrics that reward overlap; this is an unproven measurement assumption.
  • ad hoc to paper Per-benchmark hyperparameter tuning of alpha, tau, and N by QSCORE reflects general superiority rather than overfitting.
    Figure 4 identifies optimal regions on the same four test benchmarks; there is no validation split or statistical significance analysis.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Extracting Overlapping Microservices from Monolithic Code via Deep Semantic Embeddings and Graph Neural Network-Based Soft Clustering." pith.science (2026). https://pith.science/paper/F4BMXRHG

@misc{pith2026250807486,
  author       = {Pith},
  title        = {Pith review of: Extracting Overlapping Microservices from Monolithic Code via Deep Semantic Embeddings and Graph Neural Network-Based Soft Clustering},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/F4BMXRHG}},
  note         = {Machine review of arXiv:2508.07486}
}
read the original abstract

Modern software systems are increasingly shifting from monolithic architectures to microservices to enhance scalability, maintainability, and deployment flexibility. Existing microservice extraction methods typically rely on hard clustering, assigning each software component to a single microservice. This approach often increases inter-service coupling and reduces intra-service cohesion. We propose Mo2oM (Monolithic to Overlapping Microservices), a framework that formulates microservice extraction as a soft clustering problem, allowing components to belong probabilistically to multiple microservices. This approach is inspired by expert-driven decompositions, where practitioners intentionally replicate certain software components across services to reduce communication overhead. Mo2oM combines deep semantic embeddings with structural dependencies extracted from methodcall graphs to capture both functional and architectural relationships. A graph neural network-based soft clustering algorithm then generates the final set of microservices. We evaluate Mo2oM on four open-source monolithic benchmarks and compare it against eight state-of-the-art baselines. Our results demonstrate that Mo2oM achieves improvements of up to 40.97% in structural modularity (balancing cohesion and coupling), 58% in inter-service call percentage (communication overhead), 26.16% in interface number (modularity and decoupling), and 38.96% in non-extreme distribution (service size balance) across all benchmarks.

Figures

Figures reproduced from arXiv: 2508.07486 by the authors.

Figure 1
Figure 1. Our Motivation. Example of overlapping class memberships in the Spring Petclinic1microservices archi￾tecture. The MetricConfig class is shared across the Customers and Visits microservices to support cross-cutting metrics functionality, illustrating the need for soft clustering rather than strict partitioning. tightly-coupled codebase where all components are devel￾oped, deployed, and scaled as one unit. Within such… view at source ↗
Figure 2
Figure 2. Overview of the Mo2oM Decomposition Framework. The pipeline involves parsing the monolithic application, extracting structural and semantic features from classes, and applying soft clustering to generate candidate microservices. Algorithm 1: AST Flattening (F) Require: AST node n {Current subtree root} 1: Initialize ak ← [] 2: if n is a leaf node then 3: ak ← ak ⊕ n.name 4: else 5: ak ← ak ⊕ n.name :: left 6: for ea… view at source ↗
Figure 3
Figure 3. Microservice Decomposition with Soft vs. Hard Clustering (JPetStore). Comparison of (a) soft clustering (UniX￾coder + Soft) and (b) hard clustering (UniXcoder + Hard). Green lines: intra-service calls; red lines: inter-service calls; blue ellipses: multifunctional classes. Soft clustering reduces inter-service dependencies by allowing shared class ownership. Method SM ↑ ICP ↓ IFN ↓ NED ↓ JPetStore UniXcoder + Hard 0… view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Hyperparameter Sensitivity Analysis of Mo2oM Using QSCORE. This figure illustrates the impact of α and τ on QSCORE across benchmarks, showing optimal configurations. ent α and τ configurations across four benchmarks. In these heatmaps, brighter colors (yellow) indicate…
Figure 5
Figure 5. Figure 5: Quality metrics for original versus Mo2oM-refactored decompositions across thirteen real-world microservices ap [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. SCPP: A Unified Python Library for Soft Clustering

    cs.LG 2026-07 conditional novelty 6.0 of 10

    SCPP provides a unified Python API, benchmarking suite, and 241 tests covering 40 soft clustering algorithms.

Reference graph

Works this paper leans on

46 extracted references · 44 canonical work pages · cited by 1 Pith paper

  1. [1]

    Abgaz, Y .; McCarren, A.; Elger, P.; Solan, D.; Lapuz, N.; Bivol, M.; Jackson, G.; Yilmaz, M.; Buckley, J.; and Clarke, P. 2023. Decomposition of monolith appli- cations into microservices architectures: A systematic review. IEEE Transactions on Software Engineering , 49(8): 4213–4242

    work page 2023

  2. [2]

    Barzotto, T. R. H.; and Farias, K. 2022. Evaluation of the impacts of decomposing a monolithic applica- tion into microservices: A case study. arXiv preprint arXiv:2203.13878

    work page Pith review arXiv 2022

  3. [3]

    Desai, U.; Bandyopadhyay, S.; and Tamilselvam, S

    work page

  4. [4]

    Desina, G. C. 2023. Evaluating the impact of cloud- based microservices architecture on application perfor- mance. arXiv preprint arXiv:2305.15438

    work page Pith review arXiv 2023

  5. [5]

    Guo, D.; Lu, S.; Duan, N.; Wang, Y .; Zhou, M.; and Yin, J. 2022. Unixcoder: Unified cross-modal pre-training for code representation. arXiv preprint arXiv:2203.03850

    arXiv 2022

  6. [6]

    Gysel, M.; K ¨olbener, L.; Giersche, W.; and Zimmer- mann, O. 2016. Service cutter: A systematic approach to service decomposition. In European Conference on Service-Oriented and Cloud Computing , 185–200. Springer

    work page 2016

  7. [7]

    I.; Murdha, A

    Habib, P. I.; Murdha, A. S.; Agus, H.; and Suhardi

    work page

  8. [8]

    Henr ´ıquez, C.; Valencia, J. D. R.; and Torres, G. S

    work page

Show all 46 references
  1. [9]

    Hou, X.; Zhao, Y .; Liu, Y .; Yang, Z.; Wang, K.; Li, L.; Luo, X.; Lo, D.; Grundy, J.; and Wang, H. 2024. Large language models for software engineering: A system- atic literature review. ACM Transactions on Software Engineering and Methodology, 33(8): 1–79

    2024

  2. [10]

    Imranur, M.; Panichella, S.; Taibi, D.; et al. 2019. A curated dataset of microservices-based systems. arXiv preprint arXiv:1909.03249

    2019 arXiv

  3. [11]

    Jin, W.; Liu, T.; Cai, Y .; Kazman, R.; Mo, R.; and Zheng, Q. 2019. Service candidate identification from monolithic systems based on execution traces. IEEE Transactions on Software Engineering , 47(5): 987– 1007

    2019

  4. [12]

    K.; Xiao, J.; Krishna, R.; Sinha, S.; Vukovic, M.; and Banerjee, D

    Kalia, A. K.; Xiao, J.; Krishna, R.; Sinha, S.; Vukovic, M.; and Banerjee, D. 2021. Mono2micro: a practical and effective tool for decomposing monolithic java ap- plications to microservices. In Proceedings of the 29th ACM joint meeting on European software engineering confere...

    2021

  5. [13]

    K.; Xiao, J.; Lin, C.; Sinha, S.; Rofrano, J.; Vukovic, M.; and Banerjee, D

    Kalia, A. K.; Xiao, J.; Lin, C.; Sinha, S.; Rofrano, J.; Vukovic, M.; and Banerjee, D. 2020. Mono2micro: an ai-based toolchain for evolving monolithic enterprise applications to a microservice architecture. In Pro- ceedings of the 28th ACM Joint Meeting on European Software En...

    2020

  6. [14]

    Kalske, M.; et al. 2017. Transforming monolithic ar- chitecture towards microservice architecture. Univer- sity of Helsinki

    2017

  7. [15]

    Kapikul, A.; Savi ´c, D.; Mili ´c, M.; and Antovi ´c, I

  8. [16]

    Katal, A.; Prasanna, P.; Birla, R.; and Kunal. 2025. Evolution from Monolithic to Microservices Architec- ture: A New Era in Software Architecture. InAdvance- ments in Optimization and Nature-Inspired Comput- ing for Solutions in Contemporary Engineering Chal- lenges, 235–279....

    2025

  9. [17]

    Koschke, R. 2000. Evaluation of automatic re- modularization techniques and their integration in a semi-automatic method. Ph.D. thesis, PhD thesis, Uni- versity of Stuttgart, Stuttgart, Germany

    2000

  10. [18]

    S.; Chen, Y .; and Gansner, E

    Mancoridis, S.; Mitchell, B. S.; Chen, Y .; and Gansner, E. R. 1999. Bunch: A clustering tool for the recovery and maintenance of software system structures. InPro- ceedings IEEE International Conference on Software Maintenance-1999 (ICSM’99). ’Software Maintenance for Busines...

    1999

  11. [19]

    In 2024 28th International Conference on Information Technology (IT), 1–4

    Application Development From Monolithic to Microservice Architecture. In 2024 28th International Conference on Information Technology (IT), 1–4

    2024

  12. [20]

    S.; and Mancoridis, S

    Mitchell, B. S.; and Mancoridis, S. 2006. On the au- tomatic modularization of software systems using the bunch tool. IEEE Transactions on Software Engineer- ing, 32(3): 193–208

    2006

  13. [21]

    Oumoussa, I.; and Saidi, R. 2024. Evolution of Mi- croservices Identification in Monolith Decomposition: A Systematic Review.IEEE Access, 12: 23389–23405

    2024

  14. [22]

    O.; Adeleke, A

    Oyeniran, C.; Adewusi, A. O.; Adeleke, A. G.; Ak- wawa, L. A.; and Azubuko, C. F. 2024. Microservices architecture in cloud-native applications: Design pat- terns and scalability. Computer Science & IT Research Journal, 5(9): 2107–2124

    2024

  15. [23]

    Mazlami, G.; Cito, J.; and Leitner, P. 2017. Extrac- tion of microservices from monolithic software archi- tectures. In 2017 IEEE International Conference on Web Services (ICWS), 524–531. IEEE

    2017

  16. [24]

    Petridis, C. 2024. Text Classification: Neural Networks VS Machine Learning Models VS Pre-trained Models. arXiv preprint arXiv:2412.21022

    2024 arXiv

  17. [25]

    Qian, L.; Li, J.; He, X.; Gu, R.; Shao, J.; and Lu, Y

  18. [26]

    Scanniello, G.; D’Amico, A.; D’Amico, C.; and D’Amico, T. 2010. An approach for architectural layer recovery. In Proceedings of the 2010 ACM Symposium on Applied Computing, 2198–2202

    2010

  19. [27]

    Parnas, D. L. 1972. On the criteria to be used in de- composing systems into modules. Communications of the ACM, 15(12): 1053–1058

    1972

  20. [28]

    Schwanke, R. W. 1991. An intelligent tool for re- engineering software modularity. In Proceedings- 13th International Conference on Software Engineer- ing, 83–84. IEEE Computer Society

    1991

  21. [29]

    Seedat, M.; Abbas, Q.; and Ahmad, N. 2023. System- atic mapping of monolithic applications to microser- vices architecture. arXiv preprint arXiv:2309.03796

    2023 arXiv

  22. [30]

    A.; and Ouni, A

    Sellami, K.; Saied, M. A.; and Ouni, A. 2022. A hi- erarchical dbscan method for extracting microservices from monolithic applications. In Proceedings of the 26th international conference on evaluation and as- sessment in software engineering, 201–210

    2022

  23. [31]

    Shchur, O.; and G ¨unnemann, S. 2019. Overlap- ping community detection with graph neural networks. arXiv preprint arXiv:1909.12201

    2019 arXiv

  24. [32]

    Scanniello, G.; D’Amico, A.; D’Amico, C.; and D’Amico, T. 2010. Using the kleinberg algorithm and vector space model for software system clustering. In 2010 IEEE 18th International Conference on Program Comprehension, 180–189. IEEE

    2010

  25. [33]

    Su, R.; Li, X.; and Taibi, D. 2024. From Microservice to Monolith: A Multivocal Literature Review. Elec- tronics, 13(8): 1452

    2024

  26. [34]

    Tzerpos, V .; and Holt, R. C. 2000. Accd: an algorithm for comprehension-driven clustering. In Proceedings Seventh Working Conference on Reverse Engineering, 258–267. IEEE

    2000

  27. [35]

    van Bruggen, D.; Vran ´y, T.; and Tomassetti, F. 2023. JavaParser: Visited - Analyse, Transform and Generate Your Java Code Base. Leanpub. Last accessed: June 25, 2025

    2023

  28. [36]

    Van Hoorn, A.; Waller, J.; and Hasselbring, W. 2012. Kieker: A framework for application performance monitoring and dynamic software analysis. In Pro- ceedings of the 3rd ACM/SPEC international confer- ence on performance engineering, 247–248

    2012

  29. [37]

    S ¨oylemez, M.; Tekinerdogan, B.; and Kolukısa Tarhan, A. 2022. Challenges and solution directions of mi- croservice architectures: A systematic literature re- view. Applied sciences, 12(11): 5507

    2022

  30. [38]

    Yedida, R.; Krishna, R.; Kalia, A.; Menzies, T.; Xiao, J.; and Vukovic, M. 2021. Partitioning cloud-based mi- croservices (via deep learning). arXiv preprint arXiv: 2109.14569

    2021 arXiv

  31. [39]

    Yedida, R.; Krishna, R.; Kalia, A.; Menzies, T.; Xiao, J.; and Vukovic, M. 2023. An expert system for re- designing software for cloud applications. Expert Sys- tems with Applications, 219: 119673

    2023

  32. [40]

    Zhou, X.; Cao, S.; Sun, X.; and Lo, D. 2025. Large lan- guage model for vulnerability detection and repair: Lit- erature review and the road ahead. ACM Transactions on Software Engineering and Methodology , 34(5): 1– 31

    2025

  33. [42]

    F.; Alon, U.; Neubig, G.; and Hellendoorn, V

    Xu, F. F.; Alon, U.; Neubig, G.; and Hellendoorn, V . J

  34. [2021]

    In Proceedings of the AAAI conference on artificial intelligence, volume 35, 72–80

    Graph neural network to dilute outliers for refac- toring monolith application. In Proceedings of the AAAI conference on artificial intelligence, volume 35, 72–80

  35. [2022]

    In Proceedings of the 6th ACM SIGPLAN international symposium on machine programming, 1– 10

    A systematic evaluation of large language mod- els of code. In Proceedings of the 6th ACM SIGPLAN international symposium on machine programming, 1– 10

  36. [2023]

    Microservice extraction using graph deep clus- tering based on dual view fusion.Information and Soft- ware Technology, 158: 107171

  37. [2024]

    IEEE Ac- cess, 12: 194630–194645

    Architecture Migration From Monolithic to Mi- croservices: Developing Readiness Criteria. IEEE Ac- cess, 12: 194630–194645

  38. [2025]

    Prospectiva, 23(1)

    Architectural Evolution at Netflix: A Case Study on Microservices and the Transformation from Mono- lithic to Scalable Systems. Prospectiva, 23(1)

Pith tools

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