Interoperable Code Representation
Programming language
Object-Oriented Code Serialization - XML, JSON, CBOR (Concise Binary Object Representation)
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

Advantages of Using a Subset of .NET API

1. Standardization of Core Functions

.NET BCL (Base Class Library) already provides robust implementations of core functionalities such as working with collections, files, strings, dates and times, networking, etc.
Using a subset ensures that fundamental functions are well-defined, tested, and optimized.

2. Portability

.NET API has clear documentation and supports language-independent design.
Implementing this API in other languages (e.g., jdotnet, pythondotnet) creates a standard foundation that remains consistent across platforms.

3. Easier Porting

Code written in C# (or another .NET subset) can be ported to other languages if compatible API implementations are available.
Example: If a C# application uses System.Collections.Generic.List, the same list structure can exist in jsdotnet as jsdotnet.List.

4. Future Maintainability

Defining a fixed API ensures consistency, which is crucial for long-term projects.
Focusing on a subset makes it easier to adapt to new technologies without requiring a full system rewrite.

How to Design a .NET API Subset

Focus on Core Features

Data Types: System.String, System.Int32, System.Double, System.Boolean.
Collections: System.Collections.Generic.List, Dictionary, Queue.
I/O Operations: System.IO.File, System.IO.Stream.
Date and Time: System.DateTime, System.TimeSpan.
Networking: System.Net.Http.HttpClient.

Avoid Platform-Dependent Components

Do not use API parts that are specific to Windows or other particular platforms (e.g., Windows Forms).
Prefer components that are cross-platform compatible (.NET Core, .NET 6+).

Design a "Subset Interface"

Example: IDotNetAPI, which defines methods and functions that must be implemented in all language versions (jdotnet, pythondotnet).

Next as an OOP programming language

Inspired by Java and C#, but its syntax is simpler.

Inspired by Python - there are no semicolons, indentation is defined by blocks.

Strongly typed

Supports OOP - classes, interfaces, inheritance

Access modifiers

+: public, accesible by everyone

-: private, accesible only inside the class

#: protected, accesible only inside the class and subclasses

~: package, accesible only inside the package

class MyClass

+int publicVariable

-String privateVariable

#void protectedMethod()

~double packageMethod()

Management of the logic flow

Conditions: if, else, switch

Loops: for, while

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.

Long-Term Sustainability (e.g., Hundreds of Years)

Challenges:

Technological Progress: Languages and platforms evolve, which may complicate long-term compatibility.
Dependency on a Specific Runtime: If .NET becomes obsolete in 100 years, a custom runtime will need to be created.
Compatibility with New Languages: The API will need to be regularly updated to remain compatible with modern languages and paradigms.

Solutions:

Defining Standards: Clearly document the API and its functionality in an independent format such as JSON, YAML, or XML for easy reconstruction.
Open-Source Model: Allow the community to contribute to the development of the API and bindings.
Automated Testing: Use robust test suites to ensure correct functionality across different platforms and versions.
Backup and Documentation: Comprehensive documentation and archiving will ensure that the API remains understandable and usable in the future.

Conclusion

This approach is excellent for ensuring the long-term sustainability and portability of the project. Using a subset of .NET classes as a standard API is a practical and robust solution.

Will Object-Oriented Programming Disappear in the Distant Future?

It is unlikely that object-oriented programming (OOP) will completely disappear, but its significance and dominance in software development may shift depending on technological trends, performance requirements, security, and maintainability.

Why OOP is Unlikely to Disappear?

Strong Foundations and Widespread Adoption:
- OOP is based on natural real-world modeling using classes and objects, making it easier to design complex systems.
- Concepts like inheritance, polymorphism, and encapsulation provide powerful tools for modularity and code reuse.
Established Practice:
- OOP is deeply integrated into programming languages like Java, C++, Python, C#, Ruby, and more.
- Millions of developers and existing projects will keep OOP relevant for many years.
Support from Modern Technologies:
- Languages like Python, Kotlin, Swift, Java, and TypeScript continue to use OOP as a core paradigm while integrating other approaches (e.g., functional programming).

Potential Changes and Declining Significance of OOP

Despite its strengths, OOP faces challenges and may be replaced or supplemented by other paradigms in certain areas:

Functional Programming (FP)
- FP is gaining popularity due to its emphasis on immutability, pure functions, and easy parallelization.
- Languages like Haskell, Scala, Rust, and FP features in Python or JavaScript show that FP can be beneficial, especially in data processing and parallel computing.
Data-Oriented Programming
- With the rise of AI, machine learning, and big data, data-centric approaches are becoming more relevant, where data structures and algorithms matter more than OOP.
Declarative and Reactive Programming
- Declarative and reactive frameworks (e.g., React, RxJS) are growing in popularity, particularly in UI development and event-driven systems.
AI and Automated Programming
- Advanced AI models could enable code generation where traditional paradigms like OOP are less critical, shifting the focus to problem description rather than manual coding.
Domain-Specific Languages (DSLs)
- In specialized fields (e.g., game development, UI design, scientific computing), DSLs may replace general-purpose languages, reducing reliance on OOP.

What Could the Future Look Like?

Hybrid Approaches:
- Future languages will likely combine multiple paradigms. Many modern languages (Kotlin, Python, Scala) already support both OOP and functional programming.
Higher-Level Abstraction:
- OOP may be replaced or transformed into paradigms with higher abstraction levels (e.g., component-based programming, modular systems).
Automated Code Generation:
- Instead of manually writing OOP code, AI could generate and optimize solutions, allowing developers to focus on concepts and architecture.

OOP in the Long Term

If technology advances to the point where traditional programming shifts towards abstract design (e.g., defining problems in natural language), OOP may become less relevant. However, its core principles—such as modularity, hierarchy, and abstraction—will likely persist in new paradigms.

Conclusion

Object-oriented programming is unlikely to vanish, but its dominance may decline as new paradigms and technologies emerge. In the long run, OOP will likely be one of many tools in a broader spectrum of approaches rather than being completely replaced.