Program Transformation

Program transformation has gained a wide interest since it is used for several purposes: altering semantics of a program, adding features to a program or performing optimizations. In this paper we focus on program transformations at the bytecode level. Because these transformations may introduce errors, our goal is to provide a formal way to verify the update and establish its correctness. The formal framework presented includes a definition of a formal semantics of updates which is the base of a static verification and a scheme based on Hoare triples and weakest precondition calculus to reason about behavioral aspects in bytecode transformation. **Notations: • Effect STK ( a,b): represents the effect of the instruction a on the stack a. • Effect F(a,b): represents the effect on the instruction a on F.

Enterprises face significant challenges in transitioning from DevOps to comprehensive platform engineering frameworks in cloud-native environments. While organizations have successfully adopted containerization and Kubernetes, systematic platform engineering evolution remains fragmented across industry sectors. The primary challenge is the absence of structured maturity models to guide progression from reactive infrastructure management to proactive platform abstraction and developer-centric automation.
This article introduces the Platform Engineering Maturity Model (PEMM), a six-dimensional framework encompassing infrastructure standardization, automation depth, governance integration, security embedding, developer self-service, and operational observability. PEMM enables organizations to benchmark current capabilities, identify transformation priorities, and establish systematic progression strategies. The framework addresses gaps in existing models by providing measurable constructs specifically designed for enterprise cloud-native transformation, validated through three enterprise implementations and interviews with twelve platform engineering practitioners across technology, finance, and telecommunications sectors. Implementation scenarios demonstrate practical utility across container orchestration, infrastructure restructuring, pipeline harmonization, and governance automation initiatives. The framework provides a structured evaluation methodology for measuring progress toward operational excellence and business scalability requirements.

A clustered architecture has been designed to exploit divide and conquer parallelism in functional programs. The programming methodology developed for the machine is based on explicit annotations and program transformations. It has been successfully applied to a number of algorithms resulting in a benchmark of small and m edium size parallel functional programs. Sophisticated compilation techniques are used such as strictness analysis on non-flat domains and R IS C and V L IW code generation. Parallel jobs are distributed by an efficient hierarchical scheduler. A special processor for graph reduction has been designed as a basic building block for the machine. A prototype of a single cluster machine has been constructed with stock hardware. This paper describes the experience with the project and its current state.

Vorwegnahme des Erkenntnisgewinns vom Abschluss der Argumentation:
Hybride Autorschaft ist damit ein paradigmatischer Musterfall für ein Subjekt, das seine Handlungs- und Orientierungsfähigkeit inmitten der Transformationsgesellschaft nicht trotz, sondern aus der permanenten, spannungsreichen Relationierung mit dem Fremden schöpft. Die Interferenz-Zone wird vom Ort des potenziellen Kontrollverlusts zum eigentlichen Bildungsraum einer Pädagogik des Neubeginns.

This article proposes a case study to evaluate the suitability of graph transformation tools for program refactoring. In order to qualify for this purpose, a graph transformation system must be able to (i) import a graph-based representation of models of J programs , (ii) allow these models to be transformed interactively with well-known program refactorings, and (iii) export the resulting models in the same graph-based format used as input. The case study aims to enable comparison of various features of graph transformation tools, such as their expressiveness and their ability to interact with the user. The model of J programs is presented and some examples for translating J source code into the model are provided. The refactorings selected for the case study are specified in detail.

Program conditioning consists of identifying and removing a set of statements which cannot be executed when a condition of interest holds at some point in a program. It has been applied to problems in maintenance, testing, re-use and re-engineering. Program conditioning relies upon both symbolic execution and reasoning about symbolic predicates. Automation of the process therefore requires some form of automated theorem proving. However, the use of a full-power 'heavyweight' theorem prover would impose unrealistic performance constraints. This paper reports on a lightweight approach to theorem proving using the FermaT simplify decision procedure. This is used as a component to ConSUS, a program conditioning system for the Wide Spectrum Language WSL. The paper describes the symbolic execution algorithm used by ConSUS, which prunes as it conditions. The paper also provides empirical evidence that conditioning produces a significant reduction in program size and, although exponential in the worst case, the conditioning system has low degree polynomial behaviour in many cases, thereby making it scalable to unit level applications of program conditioning.

A highly efficient lightweight forward static slicing approach is presented and evaluated. The approach does not compute the program/system dependence graph but instead dependence and control information is computed as needed while computing the slice on a variable. The result is a list of line numbers, dependent variables, aliases, and function calls that are part of the slice for all variables (both local and global) for the entire system. The method is implemented as a tool, called srcSlice, on top of srcML, an XML representation of source code. The approach is highly scalable and can generate the slices for all variables of the Linux kernel in approximately 20 min on a typical desktop. Benchmark results are compared with the CodeSurfer slicing tool from GrammaTech Inc., and the approach compares well with regard to accuracy of slices.

A highly efficient lightweight forward static slicing method is introduced. The method is implemented as a tool on top of srcML, an XML representation of source code. The approach does not compute the program dependence graph but instead dependency information is computed as needed while computing the slice on a variable. The result is a list of line numbers, dependent variables, aliases, and function calls that are part of the slice for a given variable. The tool produces the slice in this manner for all variables in a given system. The approach is highly scalable and can generate the slices for all variables of the Linux kernel in less than 13 minutes. Benchmark results are compared with the CodeSurfer slicing tool and the approach compares well with regards to accuracy of slices.

For memory constrained environments like embedded systems, optimization for program size is often as important, if not more important, as optimization for execution speed. Commonly, compilers try to reduce the code segment size and neglect the stack segment, although the stack can significantly grow during the execution of recursive functions as a separate activation record is required for each recursive call. An activation record holds administrative data like the return address and the frame pointer but also the function's parameter list and local variables. If a formal parameter or local variable is dead at all recursive calls, then it can be declared globally so that only one instance exists independent of the call depth. This allowed us to optimize the stack size in 70% of our benchmarks. Often, live ranges of parameters and local variables can be split at recursive calls through program transformations. Such program transformations allowed us to further optimize the stack size of all our benchmarks.

In this paper, we describe transformation recipes, which provide a high-level interface to the code transformation and code generation capability of a compiler. These recipes can be generated by compiler decision algorithms and savvy software developers. This interface is part of an auto-tuning framework that explores a set of different implementations of the same computation and automatically selects the implementation that best meets a set of optimization criteria. Along with the original computation, a transformation recipe specifies a range of implementations of the computation resulting from composing a set of high-level code transformations. In our system, an underlying polyhedral framework coupled with transformation algorithms takes this set of transformations, composes them and automatically generates correct code. We first describe an abstract interface for transformation recipes, which we propose to facilitate interoperability with other transformation frameworks. We then focus on the specific transformation recipe interface used in our compiler and present performance results on its application to kernel and library tuning and tuning of key computations in high-end applications. We also show how this framework can be used to generate and auto-tune parallel OpenMP or CUDA code from a high-level specification.

This whitepaper introduces the ResilVor8 Infinite Clarity System™, a human–system clarity architecture built around the loop Endure → Evolve → Excel across four domains: Identity, Life, Venture, and Organization. It outlines the Five‑Move Architecture—Signals, Maps, Trade‑offs, Decisions, Integration—and presents a Dual‑Growth Lens that treats human patterns and system structures as a single loop. The paper establishes a research‑grade foundation for the ResilVor8 platform and provides a citable reference for individuals, leaders, founders, learners, professionals, and practitioners seeking structural clarity as an operating advantage.

Copyright © 2026 Basavaraj Patil. All rights reserved. No part of this work may be reproduced, distributed, adapted, or implemented in products or services for commercial purposes without prior written permission from the copyright holder. For licensing inquiries and commercial use requests, contact: [email protected]. A commercial license and/or signed agreement is required before any implementation or integration into a product or service.
Custom Non-Commercial License (NC — commercial use by permission only)
Copyright © 2026 Basavaraj Patil. This work may be copied, distributed, and adapted for non-commercial purposes only, provided appropriate attribution is given to the author. Commercial use, including implementation of the framework in products or services, requires prior written permission from the copyright holder. Contact: [email protected]

A comparison of the strategies and their performance is given by Bancilhon and Ramakrishnan [41. In a careful analysis of the evaluation of some typical recursive queries invOlVing binary relations Bancilhon and Ramakrishnan observed that the Performance of a strategy is greatly influenced by the following three factors: (1) the amount of duplication of work, (2) the size of the set of potentially relevant facts, and (3) whether the intermediate results are represented as unary or binary relations. Here duplication of work means the repeated firing of an inference rule on the same data. This can happen in strategies that duplicate data (e.g., PROLOG) and in strategies that do not remember previous firings (e.g. naive evaluation and the iterative version of query/subquery). The set of potentially relevant facts is the set of tuples in the extensional database that need be consulted by a strategy in order to produce the answer to a given query. The number of potentially relevant facts tends to be large in bottom-up methods (naive and seminaive). Therefore these methods are usually coupled with some query optimization strategy that tries to reduce the number of facts consulted when the query contains bound arguments. When using a query language based on relational algebra this is done by pushing selections inside relational-algebra expressions (e.g. Cl]). In the case of a logic-based query language the same effect is obtained by examining how bindings in the query are propagated through the inference rules and by augmenting the rules with additional predicates that restrict the applicability of the rules to the relevant facts (e.g. magic sets). An algorithm for recursive query evaluation is usually organized so that it carries along a vector of intermediate relations representing the current state of the evaluation. In most methods these intermediate relations are of the same arity as those in the database, whereas e.g. the Henschen-Naqvi method employs unary relations in the evaluation of binary relations. Bancilhon and Ramakrishnan state that (in the case of binary queries) "strategies which only look at sets of nodes rather than sets of arcs perform better than those that look at sets of arcs, by an order of magnitude or more". Another aspect that must be taken into account when comparing the advantages and drawbacks of the various strategies is the application domain of a strategy. An advantage of the basic bottom-up evaluation methods (naive and seminaive) is that they are completely general: they apply to any kind of query expressed using a Datalog program (function-free Horn-clause program), or, equivalently, a set of equations over relational-algebra expressions. In these methods, no restrictions need be imposed on the complexity of the recursion, nor on the arity or binding patterns of arguments. The only restriction is that unsafe built-in predicates must not be allowed. However, using a general method to solve a simple query may not be practical if no increase in the efficiency of the evaluation can be gained from the simplicity of the query. Indeed, a current trend in the development of query-processing strategies is to recognize commonly occuring subclasses of recursive queries that can be evaluated efficiently using algorithms specially tailored to these subclasses. The subclass that has received most attention is the class of queries that can be expressed using a linearly recursive Datalog program, or, equivalently, a set of linear equations over relational-algebra expressions (see e.g. (41). For example, the Henschen-Naqvi method [7] essentially covers this class of queries. The magic-sets optimization strategy in its generalized form 151 applies to any kind of recursion, but the computation of the magic sets can be made easy only in the case of linear

Database reengineering consists in deriving a new database from a legacy database and adapting associated software components accordingly. This migration process typically involves three main steps, namely schema conversion, data conversion and program conversion. This paper presents a wrapper-based approach to automating the program conversion step. The proposed approach combines program transformations and code generation, which are derived from schema transformations.

Database reengineering consists of deriving a new database from a legacy database and adapting the software components accordingly. This migration process involves three main steps, namely schema conversion, data conversion and program conversion. This paper explores the feasibility of transforming the application programs through code transformation patterns that are automatically derived from the database transformations. It presents the principles of a new transformational approach coupling database and program transformations and it describes a prototype CASE tool based on this approach.

We define a reduction system Ë ¿ which preserves the stable semantics. This system includes two types of transformation rules. One type (which we call Ë ¾ ) preserves the stable semantics regardless of the EDB (extensional database). So, it can be used at compilation time. The other (which we call Ë ½ ) does not preserve the stable semantics across changes to the EDB. Thus, it should be used at run time. Nonetheless Ë ½ can reduce the program size considerably and is quadratic time computable. Sometimes Ë ¿ can transform a cyclic program into an acyclic one. At these times, a satisfiability solver can be used to obtain the stable models.

This paper presents an overview of a framework for the synthesis of high-level program descriptions from traces and example pairs in an automatic programming system. The framework is described in terms of a methodology and a rule base for generating control and data structure specifications for the program to be synthesized, in a format suitable for transformation into program code in a given target language.

Metamorphic malware continuously modify their code, while preserving their functionality, in order to foil misuse detection. The key for defeating metamorphism relies in a semantic characterization of the embedding of the malware into the target program. Indeed, a behavioral model of program infection that does not relay on syntactic program features should be able to defeat metamorphism. Moreover, a general model of infection should be able to express dependences and interactions between the malicious code and the target program. ANI is a general theory for the analysis of dependences of data in a program. We propose an high order theory for ANI, later called HOANI, that allows to study program dependencies. Our idea is then to formalize and study the malware detection problem in terms of HOANI.

There has been a great deal of interest in logic programming languages in recent years. This is due, in great part, to the advantages offered by these languages: declarative readings of programs and separation of program logic from control. However, logic programs can often be dismayingly inefficient. The usual solution to this problem has been to return some control to the user in the form of impure language features like cut. Unfortunately, this often results in the loss of precisely those features that made logic programming attractive in the first place. We argue that it is not necessary to resort to such impure features for efficiency. This point is illustrated by considering how most of the common uses of cut can be eliminated from Prolog source programs, relying on static analysis to generate them at compile time. Three common situations where the cut is used are considered. Static analysis techniques are given to detect such situations, and applicable program transformations are described. We also suggest two language constructs, firstof and oneof, for situations involving ''don't-care'' nondeterminism. These constructs have better declarative readings than the cut, and extend better to parallel evaluation strategies. Together, these proposals result in a system where users need rely much less on cuts for efficiency, thereby promoting a purer programming style without sacrificing efficiency.

Large enterprises running mission-critical legacy systems for decades, such as Layer-1 network fault-management platforms, seek the agility of hybrid-cloud deployments without service disruption. This paper emphasizes best practices for migrating monolithic, on-premises applications to containerized, Infrastructure-as-Code (IaC) pipelines spanning on-prem and public clouds (Azure, AWS). We generalize learnings from a telecom fault-management modernization by assessing stateful dependencies, applying the Strangler Fig pattern for incremental decomposition, codifying policies via Open Policy Agent, and orchestrating blue/green field cutovers. Key outcomes across two pilot programs include:

45–60 % reduction in deployment lead time
70 % fewer manual remediation tickets during rollout
30 % improvement in fault-detection-to-resolution time
100 % policy compliance via automated checks
We present an extensible five-phase framework, diagrams illustrating architecture and workflow, quantitative findings, and a roadmap guiding transformation leaders through common pitfalls and decisions.

Enterprises frequently develop disparate CI/CD pipelines across different teams, resulting in inconsistent practices, quality deficiencies, and governance vulnerabilities. To address these challenges, we present EntDevOps, a standardized DevOps pipeline framework that integrates a centralized template library, policy-as-code checkpoints, and consolidated metrics. Over a six-month period, EntDevOps was deployed within three projects in network services and analytics. Prototype assessment demonstrated the following outcomes:

48% reduction in build failures (from 25% to 13%)
35% decrease in mean commit-to-deploy time (from 42 minutes to 27 minutes)
72% improvement in automated policy compliance rates (from 58% to 100%)
22% increase in team satisfaction scores
This report discusses framework architecture, implementation methodology, architectural and workflow diagrams, quantitative evaluation results, and key insights gained. The recommended best practices provide enterprises with a framework to implement consistent, secure, and efficient DevOps processes across the organization.

The goal of knowledge compilation is to transform programs in order to speed up their evaluation. In Inductive Logic Programming, two major approaches to speed-up learning exist: Approaches that intertwine the learning and the optimization process and approaches that separate these two processes. We follow the latter approach and present a new equivalence-preserving transformation method for programs with ordered clauses. It eliminates redundancies that make forward inference procedures slow. We introduce general chain rules, a specific class of ordered clauses, whose syntactical features are exploited in a new forward inference method. The comparison of the time needed by this method to evaluate the transformed program with the time needed by a standard forward inference procedure for the original program confirms the expected speed-up.

Evolutionary structural testing uses specific approaches based on guided searches that involve evaluating fitness functions to determine whether test data satisfy or not various structural testing criteria. For testing switch-case constructs the nested if-then-else structure and Alternative Critical Branches (ACBs) approaches were used so far. In this paper a new evolutionary structural approach based on Compact and Minimized Control Flow Graph (CMCFG), which is derived from the concept of Control Flow Graph (CFG), is presented. Experiments on different levels of imbrications demonstrate that this new approach has significantly better results in finding test data which cover a particular target branch in comparison with the previous approaches reported in the literature.

This paper presents the Adaptive Structural Convergence (A-SSC) framework, a rigorous polynomial-time approach for solving structured NP-complete instances such as low-rank constraints or symmetric graphs. By combining localized recursive simplicial partitioning with the Localized Lasserre Hierarchy, the framework guarantees zero-gap solutions within polynomial bounds P for these structured classes. We provide a mathematical characterization of the Bayesian-Hessian flow, demonstrating how latent structures guide the search through complex manifolds while bypassing non-contributing regions of the solution space.

Since the 1980s, software maintenance started to attract attention. Some progress has been made in using formal methods on software maintenance, especially on reverse engineering. This paper attempts to summarise some major advances in this area over the last one and a half decades. Firstly, w e introduce program transformation techniques for software development and review the techniques used for software maintenance. We then describe a method for reverse engineering and reusing COBOL programs using program transformations. Finally, w e suggest a future investigation direction for this work.

W swojej pracy twórczej i terapeutycznej od lat obserwuję, że marzenia nie zawsze realizują się w formie dosłownej. Czasem przychodzą do nas w przestrzeni symbolicznej, literackiej, energetycznej-i dopiero tam ujawniają swoją pełnię. Często jednak tej pełni nie dostrzegamy, ponieważ blokują nas schematy myślenia oraz przekonanie, że spełnienie musi mieć formę materialną. Przykładem takiego procesu jest moja książka Dom nad wodą, powstała z udziałem Aleksandry. Opisuję w niej przestrzeń, relacje i obrazy noszone przeze mnie przez lata jako marzenie o własnym

Recursive programs may require large numbers of procedure calls and stack operations, and many such recursive programs exhibit exponential time complexity, due to the time spent re-calculating already computed sub-problems. As a result, methods which transform a given recursive program to an iterative one have been intensively studied. We propose here a new framework for transforming programs by removing recursion. The framework includes a unified method of deriving low time-complexity programs by solving recurrences extracted from the program sources. Our prototype system, 9 A@ $B ¢C ¥D FE , is an initial implementation of the framework, au- tomatically finding simpler "closed form" versions of a class of recursive programs. Though in general the solution of recurrences is easier if the functions have only a single recursion parameter, we show a practical technique for solving those with multiple recursion parameters.

This volume contains the papers of the tenth annual Workshop on Scheme and Functional Programming, held August 22nd at Northeastern University in close proximity to the Symposium in honor of Mitchell Wand. The Workshop recevied eighteen submissions this year, and accepted fifteen of these. In addition, we’re pleased to include in the workshop an invited talk by Emmanuel Schanzer, on the Bootstrap program, and a talk by the newly elected Scheme Language Steering committee on the future directions of Scheme. Many people worked hard to make the Scheme Workshop happen. I would like to thank the Program Committee, along with two external reviewers, Christopher Dutchyn and Daniel King, for their thoughtful, detailed, and well-received reviews. The Scheme Workshop would also never have taken place without the marvelous and timely work done by the Northeastern University development office staff headed by Jenn Wong. We used the Continue2 submission server to handle workshop submissions and ...

The extraction of strictness information marks an indispensable element of an e cient compilation of lazy functional languages like Haskell. Based on the method of abstract reduction we h a ve developed an e cient strictness analyser for a core language of Haskell. It is completely written in Haskell and compares favourably with known implementations. The implementation is based on the G # -machine, which is an extension of the G-machine that has been adapted to the needs of abstract reduction.

The Java Virtual Machine (JVM) remains one of the most widely adopted execution platforms for enterprise-grade software systems; however, the rapid evolution of distributed service-oriented architectures, cloud platforms, and high-throughput applications has exposed significant limitations in traditional monitoring techniques for diagnosing performance bottlenecks, runtime anomalies, and system failures. This paper presents a comprehensive study of observability and monitoring approaches for JVM-based systems, spanning JVMnative diagnostic tools, bytecode-and virtual-machine-level instrumentation, adaptive profiling frameworks, application performance monitoring (APM) platforms, and external time-series telemetry systems. Using representative frameworks and tools such as ScALPEL, the JVM Marker Tracing Framework (MTF), inspectIT, FusionReactor, and Graphite, the study systematically analyzes architectural trade-offs among visibility depth, runtime overhead, instrumentation intrusiveness, and system scalability. The paper further discusses how adaptive instrumentation and layered monitoring architectures mitigate the inherent tension between finegrained observability and production performance constraints. The results indicate that hybrid observability models combining low-overhead JVM metrics, selective deep profiling, transaction-level APM, and scalable telemetry pipelines offer the most balanced and reliable strategy for achieving production-grade observability in large-scale JVM-based systems.

Digital transformation is a key organizational strategy, yet data-intensive systems and artificial intelligence amplify ethical dilemmas and contested value choices. Prior reviews cover digital transformation, AI ethics, and corporate digital responsibility, but rarely explain how ethical principles and axiological values are operationalized across the strategic lifecycle. This systematic literature review maps integration mechanisms in strategy formulation and implementation, identifies the ethical orientations that underpin them, and synthesizes recurring barriers and responses. We screened Scopus journal articles in English published from 2019 to 2025 and appraised quality using the Mixed Methods Appraisal Tool; 70 medium or high quality studies were synthesized through narrative synthesis and reflexive thematic analysis. Ethics and axiology are most often embedded through governance arrangements and formal policies, supported by stakeholder engagement and transparency and accountability practices. Explicit references to classical normative theories are less frequent than applied framings grounded in stakeholder orientation, responsibility, and responsible AI. Common barriers include governance gaps, cultural resistance, cybersecurity risks, and privacy concerns, and responses emphasize strengthened governance, capability building, and auditable oversight. The review's novelty is a lifecycle-oriented synthesis that links normative foundations to concrete, auditable strategic mechanisms. It translates fragmented debates into a transferable, mechanism-based map that can guide governance design and future empirical testing. Based on these patterns, we propose an axiological lens as a practical strategic compass for making value commitments explicit, actionable, and continuously evaluated.