SearcharxivSearch

arXiv subjects

Momil Seedat

Publications and source records attributed to Momil Seedat.

3 recordsLinked to original sources

A Topology-Aware, Memory-Centric Architecture that Separates Root-Cause Derivation from Root-Cause Explanation

Modern microservice deployments fail in ways that are easy to detect and hard to explain. When a fault propagates along service dependencies, alerts fire in floods, dashboards multiply, and the scarce resource, an engineer who understands how the services relate, is consumed reconstructing context that the monitoring stack discarded. We argue that the missing ingredient in autonomous operations is not a better anomaly detector or a larger language model, but operational memory: a persistent, structured representation of how a system normally behaves, how its parts depend on one another, and how it has failed before. We present O PS C ORTEX, a working multi-agent prototype that organizes this memory into four tiers and uses it to separate two tasks the field usually conflates: deriving a root cause and explaining it. Root cause is computed deterministically from a learned dependency graph and the temporal ordering of threshold crossings; a large language model (LLM) is then asked only to explain, confirm, and recommend, using evidence the system has already assembled. We motivate the design with two documented production cascading failures, review representative literature on observability, anomaly detection, graph-based localization, and LLM-assisted diagnosis, and show how each architectural choice maps directly to a failure mode those incidents exhibit. The prototype is validated on an instrumented e-commerce benchmark with eight injectable failure scenarios.

cs.SE

Toward Semantically-Seeded, Graph-Propagated Impact Analysis Across Software Artifacts: A Vision

When a single software artifact changes - a requirement, a configuration value, or a function - engineers must determine what else is impacted. Existing change-impact-analysis (CIA) tooling tends to rely on one of two signals in isolation: semantic similarity recovered from text (information-retrieval traceability, code search, embeddings), or structural dependency following (call graphs, IDE "find usages", test-impact selection). Each has a characteristic blind spot. A semantically driven tool misses an impacted artifact whose text shares no vocabulary with the change; a structurally driven tool misses artifacts related in meaning but not joined by an edge, and most operate only over code rather than the Requirement-Config-Service-Test chain. We argue for a training-free and interpretable analyzer that fuses both signals over the same embeddings. We model the system as a heterogeneous artifact graph with typed edges recovered by static analysis, compute a semantic prior by cosine similarity to the changed artifact, propagate impact multi-hop with decay over a row-normalized propagation matrix, and blend the two with a single tunable weight lambda. A small but complete proof-of-concept on a payment subsystem (5 labelled change scenarios) shows the mechanism we care about: artifacts with zero textual overlap with the change are still recovered through propagation, and helper functions that propagation alone cannot reach are recovered through the semantic layer. The fusion is the only configuration that covers both blind spots, and lambda acts as an explicit precision/recall control. Drawing on four publicly documented production failures, we argue that the same formulation extends to operational artifacts (images, metrics, dashboards, data schemas) that code-only analysis cannot reach.

cs.SE

Systematic Mapping of Monolithic Applications to Microservices Architecture

The aim of this paper to provide the solution microservices architecture as a popular alternative to monolithic architecture. It discusses the advantages of microservices and the challenges that organizations face when transitioning from a monolithic system. It presents a case study of a financial application and proposed techniques for identifying microservices on monolithic systems using domain-driven development concepts. In recent years, microservices architecture has emerged as a new architectural style in the software development industry. As legacy monolithic software becomes too large to manage, many large corporations are considering converting their traditional monolithic systems into small-scale, self-contained microservices. However, migrating from monolithic to microservices architecture is a difficult and challenging task. It presents a comparison of the two architectural styles and discusses the difficulties that led companies to switch to microservices. The study's findings suggest that the proposed technique can improve work performance and establish clear models, but it may not be useful for systems with lower levels of complexity. This research paper has practical implications for software architects and developers who are considering migrating from monolithic to microservices architecture.

cs.SE