Interoperable Code Representation
Programming language
Object-Oriented Code Serialization - JSON or XML
Its API library is emulation of subset of .NET classes written in Java, JavaScript and others
Using subset of programming languages like C#, Java and JavaScript:
- Data types: numbers, strings, booleans, objects
- Management of the flow of the logic: if, while, for, switch
- Object oriented principles: classes, inheritance, interfaces, encapsulation

Abstract Syntax Tree (AST) is used to represent the syntax structure of the source code. This form is then transformed to the target programming language.

Limitations and Challenges

Semantic Differences: Each language has unique features (e.g. memory management, syntax, type system), which can make accurate translation difficult.

Performance: Generated code may not always be optimized.

Libraries and APIs: Library dependencies are often language-specific.

How to write code, which is easily transferable between programming languages

Following proven design patterns allows you to write code that is easily portable.

Examples:

Factory Pattern: Creating objects without specifying a specific class.

Adapter Pattern: Converting the interface of one system to another.

Strategy Pattern: Defining families of algorithms that can be used interchangeably. Using design patterns can isolate dependencies on specific language elements and make conversions easier.

API library

C# - subset of .Net classes

Java - JDotNet

JavaScript - JSDotNet

Programming language with basic OOP principles suitable to be supported by Next

1. Common Object-Oriented Languages

These languages share similar core OOP principles:

Java: Fully supports OOP, common flow control structures, and basic data types.
C#: Very similar to Java, supports standard OOP constructs.
C++: While allowing low-level programming, it fully supports OOP.
Python: Has a flexible OOP approach and common constructs.
Ruby: A purely object-oriented language.
Kotlin: A modern language with full OOP support.
Swift: An object-oriented language used for development in the Apple ecosystem.

2. Languages with OOP Support (Though Not Primarily Object-Oriented)

These languages allow the use of OOP paradigms, even though they are not fully OOP:

JavaScript: Despite using prototype-based inheritance, classes and OOP constructs are available since ES6.
TypeScript: A superset of JavaScript with strong typing and better OOP support.
PHP: Since version 5, it offers robust OOP support.
Go (Golang): Does not support inheritance but allows interfaces and encapsulation.
Rust: Not a pure OOP language, but it provides support for structs, methods, and traits (equivalent to interfaces).

3. Scripting and Dynamically Typed Languages

OOP principles can be applied in these languages:

Perl: Supports objects and classes.
Lua: While not a typical OOP language, it allows the creation of object-oriented structures.
Ruby: Fully supports OOP and has a highly portable design.
Python: Very flexible with full OOP support.

4. Functional-Object-Oriented Languages

These languages combine OOP and functional programming:

Scala: Runs on the JVM, supports both OOP and functional paradigms.
Haskell: Supports object-like constructs through type classes.
Erlang/Elixir: Not primarily OOP but allow encapsulation and hierarchical models.

5. Statically Typed Languages with OOP Support

These languages support robust OOP constructs and are suitable for portable designs:

Ada: An older language with OOP support.
D: A modern language combining features of C++ and Python.
Objective-C: An OOP language mainly used for the Apple ecosystem (replaced by Swift).
Vala: An OOP language for GNOME, inspired by C# and Java.

6. Platform-Independent and Scripting Languages

Shell (Bash, PowerShell): While not object-oriented, some OOP-like constructs can be implemented (e.g., PowerShell is more object-oriented).
R: A statistics-oriented language that supports OOP (S3 and S4 objects).

Summary of Language Criteria

To support an object-oriented approach, a language should:

Provide fundamental data types (numbers, strings, lists, dictionaries).
Support flow control structures (if, while, for).
Allow the use of classes, interfaces, encapsulation, and polymorphism.
Be flexible enough not to limit the implementation of general constructs.