Comparing Rule-Based and AI Methods for Code Conversion – Part 1

Introduction

In the modern programming world, there is often a need to transfer a codebase from one language to another. This can be caused by various reasons:

• Language obsolescence: Some programming languages lose their relevance and support over time. For example, projects written in COBOL or Fortran may be migrated to more modern languages like Python or Java to take advantage of new features and improved support.
• Integration with new technologies: In some cases, integration with new technologies or platforms that only support certain programming languages is required. For example, mobile applications may require code transfer to Swift or Kotlin to work on iOS and Android, respectively.
• Performance improvement: Migrating code to a more efficient language can significantly improve application performance. For example, converting computationally intensive tasks from Python to C++ can lead to a significant acceleration in execution.
• Market reach expansion: Developers can create a product on a platform convenient for them and then automatically convert the source code into other popular programming languages with each new release. This eliminates the need for parallel development and synchronization of multiple codebases, significantly simplifying the development and maintenance process. For example, a project written in C# can be converted for use in Java, Swift, C++, Python, and other languages.

Code translation has become particularly relevant recently. The rapid development of technology and the emergence of new programming languages encourage developers to take advantage of them, necessitating the migration of existing projects to more modern platforms. Fortunately, modern tools have significantly simplified and accelerated this process. Automatic code conversion allows developers to easily adapt their products for various programming languages, greatly expanding the potential market and simplifying the release of new product versions.

Code Translation Methods

There are two main approaches to code translation: rule-based and AI-based translation using large language models (LLMs) such as ChatGPT and Llama:

1. Rule-based translation

This method relies on predefined rules and templates that describe how elements of the source language should be transformed into elements of the target language. It requires careful development and testing of rules to ensure accurate and predictable code conversion.

Advantages:

• Predictability and stability: The translation results are always the same with identical input data.
• Control over the process: Developers can fine-tune the rules for specific cases and requirements.
• High accuracy: With properly configured rules, high translation accuracy can be achieved.

Disadvantages:

• Labor-intensive: Developing and maintaining rules requires significant effort and time.
• Limited flexibility: It is difficult to adapt to new languages or changes in programming languages.
• Handling ambiguities: Rules may not always correctly handle complex or ambiguous code constructs.

2. AI-based translation

This method uses large language models trained on vast amounts of data, capable of understanding and generating code in various programming languages. Models can automatically convert code, considering context and semantics.

Advantages:

• Flexibility: Models can work with any pairs of programming languages.
• Automation: Minimal effort from developers to set up and run the translation process.
• Handling ambiguities: Models can consider context and handle ambiguities in the code.

Disadvantages:

• Dependence on data quality: The quality of translation heavily depends on the data the model was trained on.
• Unpredictability: Results may vary with each run, complicating debugging and modification.
• Volume limitations: Translating large projects can be problematic due to limitations on the amount of data that can be processed by the model at once.

Let's explore these methods in more detail.

Rule-Based Code Translation

Rule-based code translation has a long history, starting with the first compilers that used strict algorithms to convert source code into machine code. Nowadays, there are translators capable of converting code from one programming language to another, taking into account the specifics of code execution in the new language environment. However, this task is often more complex than translating code directly into machine code for the following reasons:

• Syntactic differences: Each programming language has its unique syntactic rules that must be considered during translation.
• Semantic differences: Different languages may have various semantic constructs and programming paradigms. For example, exception handling, memory management, and multithreading can differ significantly between languages.
• Libraries and frameworks: When translating code, dependencies on libraries and frameworks must be considered, which may not have equivalents in the target language. This requires either finding equivalents in the target language or writing additional wrappers and adapters for existing libraries.
• Performance optimization: Code that performs well in one language may be inefficient in another. Translators must account for these differences and optimize the code for the new environment.

Thus, rule-based code translation requires careful analysis and consideration of many factors.

Principles of rule-based code translation

The main principles include using syntactic and semantic rules for code transformation. These rules can be simple, such as syntax replacement, or complex, involving changes in code structure. Overall, they may include the following elements:

• Syntactic correspondences: Rules that match data structures and operations between two languages. For example, in C#, there is a do-while construct that has no direct equivalent in Python. Therefore, it can be transformed into a while loop with a pre-execution of the loop body:

var i = 0;
do 
{
    // loop body
    i++;
} while (i < n);

Translates to Python as follows:

i = 0
while True:
    # loop body
    i += 1
    if i >= n:
        break

In this case, using do-while in C# allows the loop body to execute at least once, whereas in Python, an infinite while loop with an exit condition is used.

• Logical transformations: Sometimes it is necessary to change the program logic to achieve correct behavior in another language. For example, in C#, the using construct is often used for automatic resource release, whereas in C++, this can be implemented using an explicit call to the Dispose() method:

using (var resource = new Resource()) 
{
    // use resource
}

Translates to C++ as follows:

{
    auto resource = std::make_shared<Resource>();
    DisposeGuard __dispose_guard(resource);
    // use resource
}
// The Dispose() method will be called in the DisposeGuard destructor

In this example, the using construct in C# automatically calls the Dispose() method when exiting the block, whereas in C++, to achieve similar behavior, an additional DisposeGuard class is used, which calls the Dispose() method in its destructor.

• Data types: Type casting and conversion of operations between data types are also important parts of rule-based translation. For example, in Java, the ArrayList<Integer> type can be converted to List<int> in C#:

ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);

Translates to C# as follows:

List<int> list = new List<int>();
list.Add(1);
list.Add(2);

In this case, the use of ArrayList in Java allows working with dynamic arrays, whereas in C#, the List type is used for this purpose.

• Object-oriented constructs: Translating classes, methods, interfaces, and other object-oriented structures requires special rules to maintain the semantic integrity of the program. For example, an abstract class in Java:

public abstract class Shape 
{
    public abstract double area();
}

Translates to an equivalent abstract class in C++:

class Shape 
{
    public:
    virtual double area() const = 0; // pure virtual function
};

In this example, the abstract class in Java and the pure virtual function in C++ provide similar functionality, allowing the creation of derived classes with the implementation of the area() function.

• Functions and modules: The organization of functions and file structures must also be considered during translation. Moving functions between files, removing unnecessary files, and adding new ones may be required for the program to work correctly. For example, a function in Python:

def calculate_sum(a, b):
  return a + b

Translates to C++ with the creation of a header file and an implementation file:

calculate_sum.h

#pragma once

int calculate_sum(int a, int b);

calculate_sum.cpp

#include "headers/calculate_sum.h"

int calculate_sum(int a, int b) 
{
    return a + b;
}

In this example, the function in Python is translated to C++ with a separation into a header file and an implementation file, which is a standard practice in C++ for code organization.

The necessity of implementing standard library functionality

When translating code from one programming language to another, it is important not only to correctly translate the syntax but also to account for differences in the behavior of the standard libraries of the source and target languages. For example, the core libraries of popular languages such as C#, C++, Java, and Python — .NET Framework, STL/Boost, Java Standard Library, and Python Standard Library — may have different methods for similar classes and exhibit different behaviors when working with the same input data.

For example, in C#, the Math.Sqrt() method returns NaN (Not a Number) if the argument is negative:

double value = -1;
double result = Math.Sqrt(value);
Console.WriteLine(result);  // Output: NaN

However, in Python, the similar function math.sqrt() raises a ValueError exception:

import math

value = -1
result = math.sqrt(value)
# Raises ValueError: math domain error
print(result)

Now let's consider standard substring replacement functions in the C# and C++ languages. In C#, the String.Replace() method is used to replace all occurrences of a specified substring with another substring:

string text = "one, two, one";
string newText = text.Replace("one", "three");
Console.WriteLine(newText);  // Output: three, two, three

In C++, the std::wstring::replace() function is also used to replace part of a string with another substring:

std::wstring text = L"one, two, one";
text.replace(...

However, it has several differences:

• Syntax: It takes the starting index (which needs to be found first), the number of characters to replace, and the new string. The replacement occurs only once.
• String mutability: In C++, strings are mutable, so the std::wstring::replace() function modifies the original string, whereas in C#, the String.Replace() method creates a new string.
• Return value: It returns a reference to the modified string, while in C#, it returns a new string.

To correctly translate String.Replace() to C++ using the std::wstring::replace() function, you would need to write something like this:

std::wstring text = L"one, two, one";

std::wstring newText = text;
std::wstring oldValue = L"one";
std::wstring newValue = L"three";
size_t pos = 0;
while ((pos = newText.find(oldValue, pos)) != std::wstring::npos) 
{
    newText.replace(pos, oldValue.length(), newValue);
    pos += newValue.length();
}

std::wcout << newText << std::endl;  // Output: three, two, three

However, this is very cumbersome and not always feasible.

To solve this problem, the translator developer needs to implement the standard library of the source language in the target language and integrate it into the resulting project. This will allow the resulting code to call methods not from the standard library of the target language, but from the auxiliary library, which will execute exactly as in the source language.

In this case, the translated C++ code will look like this:

#include <system/string.h>
#include <system/console.h>

System::String text = u"one, two, one";
System::String newText = text.Replace(u"one", u"three");
System::Console::WriteLine(newText);

As we can see, it looks much simpler and very close to the syntax of the original C# code.

Thus, using an auxiliary library allows you to maintain the familiar syntax and behavior of the source language methods, which significantly simplifies the translation process and subsequent work with the code.

Conclusions

Despite advantages such as precise and predictable code conversion, stability, and reduced likelihood of errors, implementing a rule-based code translator is a highly complex and labor-intensive task. This is due to the necessity of developing sophisticated algorithms for accurately analyzing and interpreting the syntax of the source language, considering the diversity of language constructs, and ensuring support for all used libraries and frameworks. Moreover, the complexity of implementing the standard library of the source language can be comparable to the complexity of writing the translator itself.